From 6f4d36634e980bb989b9a8b762c3c622804c43dd Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Mon, 16 Mar 2015 17:14:34 -0700
Subject: Removal of RPCXML dep on LLCurl switching to LLCore::Html

---
 indra/llcorehttp/_httpoprequest.cpp    |  95 +++++++++++++++++++++++----
 indra/llcorehttp/_httpoprequest.h      |  11 +++-
 indra/llcorehttp/_httppolicyglobal.cpp |  30 +++++++++
 indra/llcorehttp/_httppolicyglobal.h   |   3 +
 indra/llcorehttp/_httpservice.cpp      |  80 ++++++++++++++++++++---
 indra/llcorehttp/_httpservice.h        |   9 ++-
 indra/llcorehttp/_refcounted.h         |  11 ++++
 indra/llcorehttp/bufferarray.h         |   2 +
 indra/llcorehttp/httpcommon.cpp        |  24 +++----
 indra/llcorehttp/httpcommon.h          | 116 ++++++++++++++++++++++++++-------
 indra/llcorehttp/httphandler.h         |   4 +-
 indra/llcorehttp/httpheaders.h         |   1 +
 indra/llcorehttp/httpoptions.cpp       |  39 ++++++++---
 indra/llcorehttp/httpoptions.h         |  31 +++++++++
 indra/llcorehttp/httprequest.cpp       |  17 +++--
 indra/llcorehttp/httprequest.h         |  17 ++++-
 indra/llcorehttp/httpresponse.h        |  25 +++++++
 17 files changed, 435 insertions(+), 80 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/_httpoprequest.cpp b/indra/llcorehttp/_httpoprequest.cpp
index b9632a7921..48e22468cd 100755
--- a/indra/llcorehttp/_httpoprequest.cpp
+++ b/indra/llcorehttp/_httpoprequest.cpp
@@ -115,8 +115,9 @@ namespace LLCore
 {
 
 
-HttpOpRequest::HttpOpRequest()
+HttpOpRequest::HttpOpRequest(HttpRequest const * const request)
 	: HttpOperation(),
+	  mRequest(request),
 	  mProcFlags(0U),
 	  mReqMethod(HOR_GET),
 	  mReqBody(NULL),
@@ -139,7 +140,8 @@ HttpOpRequest::HttpOpRequest()
 	  mPolicyRetries(0),
 	  mPolicy503Retries(0),
 	  mPolicyRetryAt(HttpTime(0)),
-	  mPolicyRetryLimit(HTTP_RETRY_COUNT_DEFAULT)
+	  mPolicyRetryLimit(HTTP_RETRY_COUNT_DEFAULT),
+	  mCallbackSSLVerify(NULL)
 {
 	// *NOTE:  As members are added, retry initialization/cleanup
 	// may need to be extended in @see prepareRequest().
@@ -267,6 +269,14 @@ void HttpOpRequest::visitNotifier(HttpRequest * request)
 		response->setContentType(mReplyConType);
 		response->setRetries(mPolicyRetries, mPolicy503Retries);
 		
+		HttpResponse::TransferStats::ptr_t stats = HttpResponse::TransferStats::ptr_t(new HttpResponse::TransferStats);
+
+		curl_easy_getinfo(mCurlHandle, CURLINFO_SIZE_DOWNLOAD, &stats->mSizeDownload);
+		curl_easy_getinfo(mCurlHandle, CURLINFO_TOTAL_TIME, &stats->mTotalTime);
+		curl_easy_getinfo(mCurlHandle, CURLINFO_SPEED_DOWNLOAD, &stats->mSpeedDownload);
+
+		response->setTransferStats(stats);
+
 		mUserHandler->onCompleted(static_cast<HttpHandle>(this), response);
 
 		response->release();
@@ -452,18 +462,8 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 	code = curl_easy_setopt(mCurlHandle, CURLOPT_ENCODING, "");
 	check_curl_easy_code(code, CURLOPT_ENCODING);
 
-	// The Linksys WRT54G V5 router has an issue with frequent
-	// DNS lookups from LAN machines.  If they happen too often,
-	// like for every HTTP request, the router gets annoyed after
-	// about 700 or so requests and starts issuing TCP RSTs to
-	// new connections.  Reuse the DNS lookups for even a few
-	// seconds and no RSTs.
-	code = curl_easy_setopt(mCurlHandle, CURLOPT_DNS_CACHE_TIMEOUT, 15);
-	check_curl_easy_code(code, CURLOPT_DNS_CACHE_TIMEOUT);
 	code = curl_easy_setopt(mCurlHandle, CURLOPT_AUTOREFERER, 1);
 	check_curl_easy_code(code, CURLOPT_AUTOREFERER);
-	code = curl_easy_setopt(mCurlHandle, CURLOPT_FOLLOWLOCATION, 1);
-	check_curl_easy_code(code, CURLOPT_FOLLOWLOCATION);
 	code = curl_easy_setopt(mCurlHandle, CURLOPT_MAXREDIRS, HTTP_REDIRECTS_DEFAULT);
 	check_curl_easy_code(code, CURLOPT_MAXREDIRS);
 	code = curl_easy_setopt(mCurlHandle, CURLOPT_WRITEFUNCTION, writeCallback);
@@ -474,11 +474,49 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 	check_curl_easy_code(code, CURLOPT_READFUNCTION);
 	code = curl_easy_setopt(mCurlHandle, CURLOPT_READDATA, this);
 	check_curl_easy_code(code, CURLOPT_READDATA);
-	code = curl_easy_setopt(mCurlHandle, CURLOPT_SSL_VERIFYPEER, 1);
+
+	code = curl_easy_setopt(mCurlHandle, CURLOPT_COOKIEFILE, "");
+	check_curl_easy_code(code, CURLOPT_COOKIEFILE);
+
+	if (gpolicy.mSslCtxCallback)
+	{
+		code = curl_easy_setopt(mCurlHandle, CURLOPT_SSL_CTX_FUNCTION, curlSslCtxCallback);
+		check_curl_easy_code(code, CURLOPT_SSL_CTX_FUNCTION);
+		code = curl_easy_setopt(mCurlHandle, CURLOPT_SSL_CTX_DATA, this);
+		check_curl_easy_code(code, CURLOPT_SSL_CTX_DATA);
+		mCallbackSSLVerify = gpolicy.mSslCtxCallback;
+	}
+
+	long follow_redirect(1L);
+	long sslPeerV(0L);
+	long sslHostV(0L);
+	long dnsCacheTimeout(15L);
+
+	if (mReqOptions)
+	{
+		follow_redirect = mReqOptions->getFollowRedirects() ? 1L : 0L;
+		sslPeerV = mReqOptions->getSSLVerifyHost() ? 0L : 1L;
+		sslHostV = mReqOptions->getSSLVerifyHost();
+		dnsCacheTimeout = mReqOptions->getDNSCacheTimeout();
+	}
+	code = curl_easy_setopt(mCurlHandle, CURLOPT_FOLLOWLOCATION, follow_redirect);
+	check_curl_easy_code(code, CURLOPT_FOLLOWLOCATION);
+
+	code = curl_easy_setopt(mCurlHandle, CURLOPT_SSL_VERIFYPEER, sslPeerV);
 	check_curl_easy_code(code, CURLOPT_SSL_VERIFYPEER);
-	code = curl_easy_setopt(mCurlHandle, CURLOPT_SSL_VERIFYHOST, 0);
+	code = curl_easy_setopt(mCurlHandle, CURLOPT_SSL_VERIFYHOST, sslHostV);
 	check_curl_easy_code(code, CURLOPT_SSL_VERIFYHOST);
 
+	// The Linksys WRT54G V5 router has an issue with frequent
+	// DNS lookups from LAN machines.  If they happen too often,
+	// like for every HTTP request, the router gets annoyed after
+	// about 700 or so requests and starts issuing TCP RSTs to
+	// new connections.  Reuse the DNS lookups for even a few
+	// seconds and no RSTs.
+	code = curl_easy_setopt(mCurlHandle, CURLOPT_DNS_CACHE_TIMEOUT, dnsCacheTimeout);
+	check_curl_easy_code(code, CURLOPT_DNS_CACHE_TIMEOUT);
+
+
 	if (gpolicy.mUseLLProxy)
 	{
 		// Use the viewer-based thread-safe API which has a
@@ -873,6 +911,35 @@ size_t HttpOpRequest::headerCallback(void * data, size_t size, size_t nmemb, voi
 }
 
 
+CURLcode HttpOpRequest::curlSslCtxCallback(CURL *curl, void *sslctx, void *userdata)
+{
+	HttpOpRequest * op(static_cast<HttpOpRequest *>(userdata));
+
+	if (op->mCallbackSSLVerify)
+	{
+		SSL_CTX * ctx = (SSL_CTX *)sslctx;
+		// disable any default verification for server certs
+		SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL);
+		// set the verification callback.
+		SSL_CTX_set_cert_verify_callback(ctx, sslCertVerifyCallback, userdata);
+		// the calls are void
+	}
+
+	return CURLE_OK;
+}
+
+int HttpOpRequest::sslCertVerifyCallback(X509_STORE_CTX *ctx, void *param)
+{
+	HttpOpRequest * op(static_cast<HttpOpRequest *>(param));
+
+	if (op->mCallbackSSLVerify)
+	{
+		op->mStatus = op->mCallbackSSLVerify(op->mReqURL, op->mUserHandler, ctx);
+	}
+
+	return (op->mStatus) ? 1 : 0;
+}
+
 int HttpOpRequest::debugCallback(CURL * handle, curl_infotype info, char * buffer, size_t len, void * userdata)
 {
 	HttpOpRequest * op(static_cast<HttpOpRequest *>(userdata));
diff --git a/indra/llcorehttp/_httpoprequest.h b/indra/llcorehttp/_httpoprequest.h
index 2f628b5aba..7a4b7c189e 100755
--- a/indra/llcorehttp/_httpoprequest.h
+++ b/indra/llcorehttp/_httpoprequest.h
@@ -33,6 +33,9 @@
 #include <string>
 #include <curl/curl.h>
 
+#include <openssl/x509_vfy.h>
+#include <openssl/ssl.h>
+
 #include "httpcommon.h"
 #include "httprequest.h"
 #include "_httpoperation.h"
@@ -63,7 +66,7 @@ class HttpOptions;
 class HttpOpRequest : public HttpOperation
 {
 public:
-	HttpOpRequest();
+	HttpOpRequest(HttpRequest const * const request);
 
 protected:
 	virtual ~HttpOpRequest();							// Use release()
@@ -151,6 +154,9 @@ protected:
 	static size_t writeCallback(void * data, size_t size, size_t nmemb, void * userdata);
 	static size_t readCallback(void * data, size_t size, size_t nmemb, void * userdata);
 	static size_t headerCallback(void * data, size_t size, size_t nmemb, void * userdata);
+	static CURLcode curlSslCtxCallback(CURL *curl, void *ssl_ctx, void *userptr);
+	static int sslCertVerifyCallback(X509_STORE_CTX *ctx, void *param);
+
 	static int debugCallback(CURL *, curl_infotype info, char * buffer, size_t len, void * userdata);
 
 protected:
@@ -159,8 +165,11 @@ protected:
 	static const unsigned int	PF_SAVE_HEADERS = 0x00000002U;
 	static const unsigned int	PF_USE_RETRY_AFTER = 0x00000004U;
 
+	HttpRequest::policyCallback	mCallbackSSLVerify;
+
 public:
 	// Request data
+	HttpRequest const * const mRequest;
 	EMethod				mReqMethod;
 	std::string			mReqURL;
 	BufferArray *		mReqBody;
diff --git a/indra/llcorehttp/_httppolicyglobal.cpp b/indra/llcorehttp/_httppolicyglobal.cpp
index 1dc95f3dce..c4ef38a815 100755
--- a/indra/llcorehttp/_httppolicyglobal.cpp
+++ b/indra/llcorehttp/_httppolicyglobal.cpp
@@ -106,6 +106,20 @@ HttpStatus HttpPolicyGlobal::set(HttpRequest::EPolicyOption opt, const std::stri
 	return HttpStatus();
 }
 
+HttpStatus HttpPolicyGlobal::set(HttpRequest::EPolicyOption opt, HttpRequest::policyCallback value)
+{
+	switch (opt)
+	{
+	case HttpRequest::PO_SSL_VERIFY_CALLBACK:
+		mSslCtxCallback = value;
+		break;
+
+	default:
+		return HttpStatus(HttpStatus::LLCORE, HE_INVALID_ARG);
+	}
+
+	return HttpStatus();
+}
 
 HttpStatus HttpPolicyGlobal::get(HttpRequest::EPolicyOption opt, long * value) const
 {
@@ -154,4 +168,20 @@ HttpStatus HttpPolicyGlobal::get(HttpRequest::EPolicyOption opt, std::string * v
 	return HttpStatus();
 }
 
+
+HttpStatus HttpPolicyGlobal::get(HttpRequest::EPolicyOption opt, HttpRequest::policyCallback * value) const
+{
+	switch (opt)
+	{
+	case HttpRequest::PO_SSL_VERIFY_CALLBACK:
+		*value = mSslCtxCallback;
+		break;
+
+	default:
+		return HttpStatus(HttpStatus::LLCORE, HE_INVALID_ARG);
+	}
+
+	return HttpStatus();
+}
+
 }  // end namespace LLCore
diff --git a/indra/llcorehttp/_httppolicyglobal.h b/indra/llcorehttp/_httppolicyglobal.h
index 67c4ba9481..1696238814 100755
--- a/indra/llcorehttp/_httppolicyglobal.h
+++ b/indra/llcorehttp/_httppolicyglobal.h
@@ -60,8 +60,10 @@ private:
 public:
 	HttpStatus set(HttpRequest::EPolicyOption opt, long value);
 	HttpStatus set(HttpRequest::EPolicyOption opt, const std::string & value);
+	HttpStatus set(HttpRequest::EPolicyOption opt, HttpRequest::policyCallback value);
 	HttpStatus get(HttpRequest::EPolicyOption opt, long * value) const;
 	HttpStatus get(HttpRequest::EPolicyOption opt, std::string * value) const;
+	HttpStatus get(HttpRequest::EPolicyOption opt, HttpRequest::policyCallback * value) const;
 	
 public:
 	long				mConnectionLimit;
@@ -70,6 +72,7 @@ public:
 	std::string			mHttpProxy;
 	long				mTrace;
 	long				mUseLLProxy;
+	HttpRequest::policyCallback	mSslCtxCallback;
 };  // end class HttpPolicyGlobal
 
 }  // end namespace LLCore
diff --git a/indra/llcorehttp/_httpservice.cpp b/indra/llcorehttp/_httpservice.cpp
index c673e1be1d..7b8aac35a8 100755
--- a/indra/llcorehttp/_httpservice.cpp
+++ b/indra/llcorehttp/_httpservice.cpp
@@ -53,15 +53,16 @@ namespace LLCore
 
 const HttpService::OptionDescriptor HttpService::sOptionDesc[] =
 { //    isLong     isDynamic  isGlobal    isClass
-	{	true,		true,		true,		true	},		// PO_CONNECTION_LIMIT
-	{	true,		true,		false,		true	},		// PO_PER_HOST_CONNECTION_LIMIT
-	{	false,		false,		true,		false	},		// PO_CA_PATH
-	{	false,		false,		true,		false	},		// PO_CA_FILE
-	{	false,		true,		true,		false	},		// PO_HTTP_PROXY
-	{	true,		true,		true,		false	},		// PO_LLPROXY
-	{	true,		true,		true,		false	},		// PO_TRACE
-	{	true,		true,		false,		true	},		// PO_ENABLE_PIPELINING
-	{	true,		true,		false,		true	}		// PO_THROTTLE_RATE
+	{	true,		true,		true,		true,		false	},		// PO_CONNECTION_LIMIT
+	{	true,		true,		false,		true,		false	},		// PO_PER_HOST_CONNECTION_LIMIT
+	{	false,		false,		true,		false,		false	},		// PO_CA_PATH
+	{	false,		false,		true,		false,		false	},		// PO_CA_FILE
+	{	false,		true,		true,		false,		false	},		// PO_HTTP_PROXY
+	{	true,		true,		true,		false,		false	},		// PO_LLPROXY
+	{	true,		true,		true,		false,		false	},		// PO_TRACE
+	{	true,		true,		false,		true,		false	},		// PO_ENABLE_PIPELINING
+	{	true,		true,		false,		true,		false	},		// PO_THROTTLE_RATE
+	{   false,		false,		true,		false,		true	}		// PO_SSL_VERIFY_CALLBACK
 };
 HttpService * HttpService::sInstance(NULL);
 volatile HttpService::EState HttpService::sState(NOT_INITIALIZED);
@@ -413,6 +414,34 @@ HttpStatus HttpService::getPolicyOption(HttpRequest::EPolicyOption opt, HttpRequ
 	return status;
 }
 
+HttpStatus HttpService::getPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t pclass,
+	HttpRequest::policyCallback * ret_value)
+{
+	HttpStatus status(HttpStatus::LLCORE, LLCore::HE_INVALID_ARG);
+
+	if (opt < HttpRequest::PO_CONNECTION_LIMIT											// option must be in range
+		|| opt >= HttpRequest::PO_LAST													// ditto
+		|| (sOptionDesc[opt].mIsLong)													// datatype is string
+		|| (pclass != HttpRequest::GLOBAL_POLICY_ID && pclass > mLastPolicy)			// pclass in valid range
+		|| (pclass == HttpRequest::GLOBAL_POLICY_ID && !sOptionDesc[opt].mIsGlobal)	// global setting permitted
+		|| (pclass != HttpRequest::GLOBAL_POLICY_ID && !sOptionDesc[opt].mIsClass))	// class setting permitted
+		// can always get, no dynamic check
+	{
+		return status;
+	}
+
+	// Only global has callback values
+	if (pclass == HttpRequest::GLOBAL_POLICY_ID)
+	{
+		HttpPolicyGlobal & opts(mPolicy->getGlobalOptions());
+
+		status = opts.get(opt, ret_value);
+	}
+
+	return status;
+}
+
+
 
 HttpStatus HttpService::setPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t pclass,
 										long value, long * ret_value)
@@ -489,6 +518,37 @@ HttpStatus HttpService::setPolicyOption(HttpRequest::EPolicyOption opt, HttpRequ
 
 	return status;
 }
-	
+
+HttpStatus HttpService::setPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t pclass,
+	HttpRequest::policyCallback value, HttpRequest::policyCallback * ret_value)
+{
+	HttpStatus status(HttpStatus::LLCORE, LLCore::HE_INVALID_ARG);
+
+	if (opt < HttpRequest::PO_CONNECTION_LIMIT											// option must be in range
+		|| opt >= HttpRequest::PO_LAST													// ditto
+		|| (sOptionDesc[opt].mIsLong)													// datatype is string
+		|| (pclass != HttpRequest::GLOBAL_POLICY_ID && pclass > mLastPolicy)			// pclass in valid range
+		|| (pclass == HttpRequest::GLOBAL_POLICY_ID && !sOptionDesc[opt].mIsGlobal)	// global setting permitted
+		|| (pclass != HttpRequest::GLOBAL_POLICY_ID && !sOptionDesc[opt].mIsClass)		// class setting permitted
+		|| (RUNNING == sState && !sOptionDesc[opt].mIsDynamic))						// dynamic setting permitted
+	{
+		return status;
+	}
+
+	// Callbacks values are always global (at this time).
+	if (pclass == HttpRequest::GLOBAL_POLICY_ID)
+	{
+		HttpPolicyGlobal & opts(mPolicy->getGlobalOptions());
+
+		status = opts.set(opt, value);
+		if (status && ret_value)
+		{
+			status = opts.get(opt, ret_value);
+		}
+	}
+
+	return status;
+}
+
 
 }  // end namespace LLCore
diff --git a/indra/llcorehttp/_httpservice.h b/indra/llcorehttp/_httpservice.h
index cf23f3ab61..699a8eaa4f 100755
--- a/indra/llcorehttp/_httpservice.h
+++ b/indra/llcorehttp/_httpservice.h
@@ -201,17 +201,24 @@ protected:
 		bool		mIsDynamic;
 		bool		mIsGlobal;
 		bool		mIsClass;
+		bool		mIsCallback;
 	};
 		
 	HttpStatus getPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t,
 							   long * ret_value);
 	HttpStatus getPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t,
 							   std::string * ret_value);
+	HttpStatus getPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t,
+								HttpRequest::policyCallback * ret_value);
+
 	HttpStatus setPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t,
 							   long value, long * ret_value);
 	HttpStatus setPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t,
 							   const std::string & value, std::string * ret_value);
-	
+	HttpStatus setPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t,
+								HttpRequest::policyCallback value, 
+								HttpRequest::policyCallback * ret_value);
+
 protected:
 	static const OptionDescriptor		sOptionDesc[HttpRequest::PO_LAST];
 	static HttpService *				sInstance;
diff --git a/indra/llcorehttp/_refcounted.h b/indra/llcorehttp/_refcounted.h
index 402e725152..cd16e2e2b4 100755
--- a/indra/llcorehttp/_refcounted.h
+++ b/indra/llcorehttp/_refcounted.h
@@ -120,7 +120,18 @@ inline void RefCounted::destroySelf()
 	delete this;
 }
 
+inline void intrusive_ptr_add_ref(RefCounted* p)
+{
+	p->addRef();
+}
+
+inline void intrusive_ptr_release(RefCounted* p)
+{
+	p->release();
+}
+
 } // end namespace LLCoreInt
 
+
 #endif	// LLCOREINT__REFCOUNTED_H_
 
diff --git a/indra/llcorehttp/bufferarray.h b/indra/llcorehttp/bufferarray.h
index 1094a435b4..9c2b991de6 100755
--- a/indra/llcorehttp/bufferarray.h
+++ b/indra/llcorehttp/bufferarray.h
@@ -73,6 +73,8 @@ public:
 	
 	BufferArray();
 
+	typedef boost::intrusive_ptr<BufferArray> ptr_t;
+
 protected:
 	virtual ~BufferArray();						// Use release()
 
diff --git a/indra/llcorehttp/httpcommon.cpp b/indra/llcorehttp/httpcommon.cpp
index 7907e958a4..1aece696e3 100755
--- a/indra/llcorehttp/httpcommon.cpp
+++ b/indra/llcorehttp/httpcommon.cpp
@@ -42,7 +42,7 @@ HttpStatus::operator unsigned long() const
 {
 	static const int shift(sizeof(unsigned long) * 4);
 
-	unsigned long result(((unsigned long) mType) << shift | (unsigned long) (int) mStatus);
+	unsigned long result(((unsigned long)mDetails->mType) << shift | (unsigned long)(int)mDetails->mStatus);
 	return result;
 }
 
@@ -131,18 +131,18 @@ std::string HttpStatus::toString() const
 	{
 		return std::string("");
 	}
-	switch (mType)
+	switch (mDetails->mType)
 	{
 	case EXT_CURL_EASY:
-		return std::string(curl_easy_strerror(CURLcode(mStatus)));
+		return std::string(curl_easy_strerror(CURLcode(mDetails->mStatus)));
 
 	case EXT_CURL_MULTI:
-		return std::string(curl_multi_strerror(CURLMcode(mStatus)));
+		return std::string(curl_multi_strerror(CURLMcode(mDetails->mStatus)));
 
 	case LLCORE:
-		if (mStatus >= 0 && mStatus < llcore_errors_count)
+		if (mDetails->mStatus >= 0 && mDetails->mStatus < llcore_errors_count)
 		{
-			return std::string(llcore_errors[mStatus]);
+			return std::string(llcore_errors[mDetails->mStatus]);
 		}
 		break;
 
@@ -154,7 +154,7 @@ std::string HttpStatus::toString() const
 			while (true)
 			{
 				int at((bottom + top) / 2);
-				if (mType == http_errors[at].mCode)
+				if (mDetails->mType == http_errors[at].mCode)
 				{
 					return std::string(http_errors[at].mText);
 				}
@@ -162,7 +162,7 @@ std::string HttpStatus::toString() const
 				{
 					break;
 				}
-				else if (mType < http_errors[at].mCode)
+				else if (mDetails->mType < http_errors[at].mCode)
 				{
 					top = at;
 				}
@@ -182,9 +182,9 @@ std::string HttpStatus::toTerseString() const
 {
 	std::ostringstream result;
 
-	unsigned int error_value((unsigned short) mStatus);
+	unsigned int error_value((unsigned short)mDetails->mStatus);
 	
-	switch (mType)
+	switch (mDetails->mType)
 	{
 	case EXT_CURL_EASY:
 		result << "Easy_";
@@ -202,7 +202,7 @@ std::string HttpStatus::toTerseString() const
 		if (isHttpStatus())
 		{
 			result << "Http_";
-			error_value = mType;
+			error_value = mDetails->mType;
 		}
 		else
 		{
@@ -244,7 +244,7 @@ bool HttpStatus::isRetryable() const
 	// Disable the '*this == inv_status' test and look for 'Core_9'
 	// failures in log files.
 
-	return ((isHttpStatus() && mType >= 499 && mType <= 599) ||	// Include special 499 in retryables
+	return ((isHttpStatus() && mDetails->mType >= 499 && mDetails->mType <= 599) ||	// Include special 499 in retryables
 			*this == cant_connect ||	// Connection reset/endpoint problems
 			*this == cant_res_proxy ||	// DNS problems
 			*this == cant_res_host ||	// DNS problems
diff --git a/indra/llcorehttp/httpcommon.h b/indra/llcorehttp/httpcommon.h
index 9601f94125..0244755272 100755
--- a/indra/llcorehttp/httpcommon.h
+++ b/indra/llcorehttp/httpcommon.h
@@ -191,7 +191,6 @@
 
 #include <string>
 
-
 namespace LLCore
 {
 
@@ -292,35 +291,35 @@ struct HttpStatus
 	typedef unsigned short type_enum_t;
 	
 	HttpStatus()
-		: mType(LLCORE),
-		  mStatus(HE_SUCCESS)
-		{}
+		{
+			mDetails = std::unique_ptr<Details>(new Details(LLCORE, HE_SUCCESS));
+		}
 
 	HttpStatus(type_enum_t type, short status)
-		: mType(type),
-		  mStatus(status)
-		{}
+		{
+			mDetails = std::unique_ptr<Details>(new Details(type, status));
+		}
 	
 	HttpStatus(int http_status)
-		: mType(http_status),
-		  mStatus(http_status >= 200 && http_status <= 299
-				  ? HE_SUCCESS
-				  : HE_REPLY_ERROR)
 		{
+			mDetails = std::unique_ptr<Details>(new Details(http_status, 
+				(http_status >= 200 && http_status <= 299) ? HE_SUCCESS : HE_REPLY_ERROR));
 			llassert(http_status >= 100 && http_status <= 999);
 		}
 	
 	HttpStatus(const HttpStatus & rhs)
-		: mType(rhs.mType),
-		  mStatus(rhs.mStatus)
-		{}
+		{
+			mDetails = std::unique_ptr<Details>(new Details(*rhs.mDetails));
+		}
 
 	HttpStatus & operator=(const HttpStatus & rhs)
 		{
 			// Don't care if lhs & rhs are the same object
+			mDetails->mType = rhs.mDetails->mType;
+			mDetails->mStatus = rhs.mDetails->mStatus;
+			mDetails->mMessage = rhs.mDetails->mMessage;
+			mDetails->mErrorData = rhs.mDetails->mErrorData;
 
-			mType = rhs.mType;
-			mStatus = rhs.mStatus;
 			return *this;
 		}
 	
@@ -328,10 +327,6 @@ struct HttpStatus
 	static const type_enum_t EXT_CURL_MULTI = 1;		///< mStatus is an error from a curl_multi_*() call
 	static const type_enum_t LLCORE = 2;				///< mStatus is an HE_* error code
 														///< 100-999 directly represent HTTP status codes
-	
-	type_enum_t			mType;
-	short				mStatus;
-
 	/// Test for successful status in the code regardless
 	/// of error source (internal, libcurl).
 	///
@@ -339,7 +334,7 @@ struct HttpStatus
 	///
 	operator bool() const
 	{
-		return 0 == mStatus;
+		return 0 == mDetails->mStatus;
 	}
 
 	/// Inverse of previous operator.
@@ -347,14 +342,15 @@ struct HttpStatus
 	/// @return			'true' on any error condition
 	bool operator !() const
 	{
-		return 0 != mStatus;
+		return 0 != mDetails->mStatus;
 	}
 
 	/// Equality and inequality tests to bypass bool conversion
 	/// which will do the wrong thing in conditional expressions.
 	bool operator==(const HttpStatus & rhs) const
 	{
-		return mType == rhs.mType && mStatus == rhs.mStatus;
+		return (mDetails->mType == rhs.mDetails->mType) && 
+			(mDetails->mStatus == rhs.mDetails->mStatus);
 	}
 
 	bool operator!=(const HttpStatus & rhs) const
@@ -395,7 +391,7 @@ struct HttpStatus
 	/// HTTP response status (100 - 999).
 	bool isHttpStatus() const
 	{
-		return 	mType >= type_enum_t(100) && mType <= type_enum_t(999);
+		return 	mDetails->mType >= type_enum_t(100) && mDetails->mType <= type_enum_t(999);
 	}
 
 	/// Returns true if the status is one that will be retried
@@ -403,7 +399,77 @@ struct HttpStatus
 	/// where that logic needs to be replicated.  Only applies
 	/// to failed statuses, successful statuses will return false.
 	bool isRetryable() const;
-	
+
+	/// Returns the currently set status code as a raw number
+	///
+	short getStatus() const
+	{
+		return mDetails->mStatus;
+	}
+
+	/// Returns the currently set status type 
+	/// 
+	type_enum_t getType() const
+	{
+		return mDetails->mType;
+	}
+
+	// TODO: There must be a better way to do this.  Don't want to set these 
+	// values here since they increase the size of a structure that is already 
+	// being passed on the stack.  Consider my options
+	/// Returns an optional error message if one has been set.
+	///
+	std::string getMessage() const
+	{
+		return mDetails->mMessage;
+	}
+
+	/// Sets an optional error message
+	/// 
+	void setMessage(const std::string &message)
+	{
+		mDetails->mMessage = message;
+	}
+
+	/// Retrieves an optionally recorded SSL certificate.
+	void * getErrorData() const
+	{
+		return mDetails->mErrorData;
+	}
+
+	/// Optionally sets an SSL certificate on this status.
+	void setErrorData(void *data)
+	{
+		mDetails->mErrorData = data;
+	}
+
+private:
+
+	struct Details
+	{
+		Details(type_enum_t type, short status):
+			mType(type),
+			mStatus(status),
+			mMessage(),
+			mErrorData(NULL)
+		{}
+
+		Details(const Details &rhs) :
+			mType(rhs.mType),
+			mStatus(rhs.mStatus),
+			mMessage(rhs.mMessage),
+			mErrorData(rhs.mErrorData)
+		{}
+
+
+		type_enum_t	mType;
+		short		mStatus;
+		std::string	mMessage;
+		void *		mErrorData;
+	};
+
+	std::unique_ptr<Details>	mDetails;
+
 }; // end struct HttpStatus
 
 }  // end namespace LLCore
diff --git a/indra/llcorehttp/httphandler.h b/indra/llcorehttp/httphandler.h
index 9171e4e7b9..740e986dec 100755
--- a/indra/llcorehttp/httphandler.h
+++ b/indra/llcorehttp/httphandler.h
@@ -45,7 +45,7 @@ class HttpResponse;
 /// be shared by any number of requests and across instances
 /// of HttpRequest running in the same thread.
 ///
-/// Threading:  HttpHandler itself is pure interface and is
+/// Threading:  HttpHandler itself is interface and is
 /// tread-compatible.  Most derivations, however, will have
 /// different constraints.
 ///
@@ -58,7 +58,7 @@ class HttpHandler
 {
 public:
 	virtual ~HttpHandler()
-		{}
+	{ }
 
 	/// Method invoked during calls to @see update().  Each invocation
 	/// represents the completion of some requested operation.  Caller
diff --git a/indra/llcorehttp/httpheaders.h b/indra/llcorehttp/httpheaders.h
index f70cd898f3..c89d6af222 100755
--- a/indra/llcorehttp/httpheaders.h
+++ b/indra/llcorehttp/httpheaders.h
@@ -92,6 +92,7 @@ public:
 	/// the instance.
 	HttpHeaders();
 
+	typedef boost::intrusive_ptr<HttpHeaders> ptr_t;
 protected:
 	virtual ~HttpHeaders();						// Use release()
 
diff --git a/indra/llcorehttp/httpoptions.cpp b/indra/llcorehttp/httpoptions.cpp
index 5bf1ecb4a5..28c2c25e92 100755
--- a/indra/llcorehttp/httpoptions.cpp
+++ b/indra/llcorehttp/httpoptions.cpp
@@ -25,7 +25,7 @@
  */
 
 #include "httpoptions.h"
-
+#include "lldefs.h"
 #include "_httpinternal.h"
 
 
@@ -33,14 +33,17 @@ namespace LLCore
 {
 
 
-HttpOptions::HttpOptions()
-	: RefCounted(true),
-	  mWantHeaders(false),
-	  mTracing(HTTP_TRACE_OFF),
-	  mTimeout(HTTP_REQUEST_TIMEOUT_DEFAULT),
-	  mTransferTimeout(HTTP_REQUEST_XFER_TIMEOUT_DEFAULT),
-	  mRetries(HTTP_RETRY_COUNT_DEFAULT),
-	  mUseRetryAfter(HTTP_USE_RETRY_AFTER_DEFAULT)
+HttpOptions::HttpOptions() : RefCounted(true),
+	mWantHeaders(false),
+	mTracing(HTTP_TRACE_OFF),
+	mTimeout(HTTP_REQUEST_TIMEOUT_DEFAULT),
+	mTransferTimeout(HTTP_REQUEST_XFER_TIMEOUT_DEFAULT),
+	mRetries(HTTP_RETRY_COUNT_DEFAULT),
+	mUseRetryAfter(HTTP_USE_RETRY_AFTER_DEFAULT),
+	mFollowRedirects(false),
+	mVerifyPeer(false),
+	mVerifyHost(0),
+	mDNSCacheTimeout(15)
 {}
 
 
@@ -82,5 +85,23 @@ void HttpOptions::setUseRetryAfter(bool use_retry)
 	mUseRetryAfter = use_retry;
 }
 
+void HttpOptions::setFollowRedirects(bool follow_redirect)
+{
+	mFollowRedirects = follow_redirect;
+}
+
+void HttpOptions::setSSLVerifyPeer(bool verify)
+{
+	mVerifyPeer = verify;
+}
 
+void HttpOptions::setSSLVerifyHost(unsigned int type)
+{
+	mVerifyHost = llclamp<unsigned int>(type, 0, 2);
+}
+
+void HttpOptions::setDNSCacheTimeout(int timeout)
+{
+	mDNSCacheTimeout = timeout;
+}
 }   // end namespace LLCore
diff --git a/indra/llcorehttp/httpoptions.h b/indra/llcorehttp/httpoptions.h
index 4ab5ff18c4..d6d892213d 100755
--- a/indra/llcorehttp/httpoptions.h
+++ b/indra/llcorehttp/httpoptions.h
@@ -61,6 +61,8 @@ class HttpOptions : public LLCoreInt::RefCounted
 public:
 	HttpOptions();
 
+	typedef boost::intrusive_ptr<HttpOptions> ptr_t;
+
 protected:
 	virtual ~HttpOptions();						// Use release()
 	
@@ -109,6 +111,31 @@ public:
 		{
 			return mUseRetryAfter;
 		}
+
+	// Default: false
+	void				setFollowRedirects(bool follow_redirect);
+	bool				getFollowRedirects() const
+		{
+			return mFollowRedirects;
+		}
+
+	void				setSSLVerifyPeer(bool verify);
+	bool				getSSLVerifyPeer() const
+		{
+			return mVerifyPeer;
+		}
+
+	void				setSSLVerifyHost(unsigned int type);
+	unsigned int		getSSLVerifyHost() const
+		{
+			return mVerifyHost;
+		}
+
+	void				setDNSCacheTimeout(int timeout);
+	int					getDNSCacheTimeout() const
+		{
+			return mDNSCacheTimeout;
+		}
 	
 protected:
 	bool				mWantHeaders;
@@ -117,6 +144,10 @@ protected:
 	unsigned int		mTransferTimeout;
 	unsigned int		mRetries;
 	bool				mUseRetryAfter;
+	bool				mFollowRedirects;
+	bool				mVerifyPeer;
+	unsigned int		mVerifyHost;
+	int					mDNSCacheTimeout;
 }; // end class HttpOptions
 
 
diff --git a/indra/llcorehttp/httprequest.cpp b/indra/llcorehttp/httprequest.cpp
index 7b1888e3eb..5f1ed3d43b 100755
--- a/indra/llcorehttp/httprequest.cpp
+++ b/indra/llcorehttp/httprequest.cpp
@@ -117,6 +117,15 @@ HttpStatus HttpRequest::setStaticPolicyOption(EPolicyOption opt, policy_t pclass
 	return HttpService::instanceOf()->setPolicyOption(opt, pclass, value, ret_value);
 }
 
+HttpStatus HttpRequest::setStaticPolicyOption(EPolicyOption opt, policy_t pclass, policyCallback value, policyCallback * ret_value)
+{
+	if (HttpService::RUNNING == HttpService::instanceOf()->getState())
+	{
+		return HttpStatus(HttpStatus::LLCORE, HE_OPT_NOT_DYNAMIC);
+	}
+
+	return HttpService::instanceOf()->setPolicyOption(opt, pclass, value, ret_value);
+}
 
 HttpHandle HttpRequest::setPolicyOption(EPolicyOption opt, policy_t pclass,
 										long value, HttpHandler * handler)
@@ -195,7 +204,7 @@ HttpHandle HttpRequest::requestGet(policy_t policy_id,
 	HttpStatus status;
 	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-	HttpOpRequest * op = new HttpOpRequest();
+	HttpOpRequest * op = new HttpOpRequest(this);
 	if (! (status = op->setupGet(policy_id, priority, url, options, headers)))
 	{
 		op->release();
@@ -229,7 +238,7 @@ HttpHandle HttpRequest::requestGetByteRange(policy_t policy_id,
 	HttpStatus status;
 	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-	HttpOpRequest * op = new HttpOpRequest();
+	HttpOpRequest * op = new HttpOpRequest(this);
 	if (! (status = op->setupGetByteRange(policy_id, priority, url, offset, len, options, headers)))
 	{
 		op->release();
@@ -262,7 +271,7 @@ HttpHandle HttpRequest::requestPost(policy_t policy_id,
 	HttpStatus status;
 	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-	HttpOpRequest * op = new HttpOpRequest();
+	HttpOpRequest * op = new HttpOpRequest(this);
 	if (! (status = op->setupPost(policy_id, priority, url, body, options, headers)))
 	{
 		op->release();
@@ -295,7 +304,7 @@ HttpHandle HttpRequest::requestPut(policy_t policy_id,
 	HttpStatus status;
 	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-	HttpOpRequest * op = new HttpOpRequest();
+	HttpOpRequest * op = new HttpOpRequest(this);
 	if (! (status = op->setupPut(policy_id, priority, url, body, options, headers)))
 	{
 		op->release();
diff --git a/indra/llcorehttp/httprequest.h b/indra/llcorehttp/httprequest.h
index 7f23723b0b..c90e056d62 100755
--- a/indra/llcorehttp/httprequest.h
+++ b/indra/llcorehttp/httprequest.h
@@ -97,6 +97,7 @@ public:
 	typedef unsigned int policy_t;
 	typedef unsigned int priority_t;
 	
+	typedef std::shared_ptr<HttpRequest> ptr_t;
 public:
 	/// @name PolicyMethods
 	/// @{
@@ -163,7 +164,7 @@ public:
 
 		/// Long value that if non-zero enables the use of the
 		/// traditional LLProxy code for http/socks5 support.  If
-		// enabled, has priority over GP_HTTP_PROXY.
+		/// enabled, has priority over GP_HTTP_PROXY.
 		///
 		/// Global only
 		PO_LLPROXY,
@@ -219,15 +220,25 @@ public:
 		/// Controls whether client-side throttling should be
 		/// performed on this policy class.  Positive values
 		/// enable throttling and specify the request rate
-		/// (requests per second) that should be targetted.
+		/// (requests per second) that should be targeted.
 		/// A value of zero, the default, specifies no throttling.
 		///
 		/// Per-class only
 		PO_THROTTLE_RATE,
 		
+		/// Controls the callback function used to control SSL CTX 
+		/// certificate verification.
+		///
+		/// Global only
+		PO_SSL_VERIFY_CALLBACK,
+
 		PO_LAST  // Always at end
 	};
 
+	/// Prototype for policy based callbacks.  The callback methods will be executed
+	/// on the worker thread so no modifications should be made to the HttpHandler object.
+	typedef HttpStatus(*policyCallback)(const std::string &, HttpHandler const * const, void *);
+
 	/// Set a policy option for a global or class parameter at
 	/// startup time (prior to thread start).
 	///
@@ -243,6 +254,8 @@ public:
 											long value, long * ret_value);
 	static HttpStatus setStaticPolicyOption(EPolicyOption opt, policy_t pclass,
 											const std::string & value, std::string * ret_value);
+	static HttpStatus setStaticPolicyOption(EPolicyOption opt, policy_t pclass,
+											policyCallback value, policyCallback * ret_value);;
 
 	/// Set a parameter on a class-based policy option.  Calls
 	/// made after the start of the servicing thread are
diff --git a/indra/llcorehttp/httpresponse.h b/indra/llcorehttp/httpresponse.h
index aee64e2878..01e9dd2bc6 100755
--- a/indra/llcorehttp/httpresponse.h
+++ b/indra/llcorehttp/httpresponse.h
@@ -69,6 +69,18 @@ protected:
 	void operator=(const HttpResponse &);				// Not defined
 	
 public:
+	/// Statistics for the HTTP 
+	struct TransferStats
+	{
+		typedef std::shared_ptr<TransferStats> ptr_t;
+
+		TransferStats() : mSizeDownload(0.0), mTotalTime(0.0), mSpeedDownload(0.0) {}
+		F64 mSizeDownload;
+		F64 mTotalTime;
+		F64 mSpeedDownload;
+	};
+
+
 	/// Returns the final status of the requested operation.
 	///
 	HttpStatus getStatus() const
@@ -168,6 +180,17 @@ public:
 			m503Retries = retries_503;
 		}
 
+	void setTransferStats(TransferStats::ptr_t &stats) 
+		{
+			mStats = stats;
+		}
+
+	TransferStats::ptr_t getTransferStats()
+		{
+			return mStats;
+		}
+
+
 protected:
 	// Response data here
 	HttpStatus			mStatus;
@@ -179,6 +202,8 @@ protected:
 	std::string			mContentType;
 	unsigned int		mRetries;
 	unsigned int		m503Retries;
+
+	TransferStats::ptr_t	mStats;
 };
 
 
-- 
cgit v1.3


From 6b8c814df3141fa705b9921ba0a73aeaa3fe63b6 Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Thu, 19 Mar 2015 17:01:21 -0700
Subject: Adding new HTTP handling for material manager.

---
 indra/llcorehttp/bufferarray.h        |   1 +
 indra/llcorehttp/httpheaders.cpp      |   2 +-
 indra/llcorehttp/httpheaders.h        |   8 ++-
 indra/llcorehttp/httpresponse.cpp     |   4 ++
 indra/llcorehttp/httpresponse.h       |   4 ++
 indra/llmessage/CMakeLists.txt        |   2 +
 indra/llmessage/llcorehttputil.cpp    |  26 +++++++
 indra/llmessage/llcorehttputil.h      |  25 +++++++
 indra/llmessage/llcurl.h              |  99 ---------------------------
 indra/llmessage/llhttpsdhandler.cpp   |  82 ++++++++++++++++++++++
 indra/llmessage/llhttpsdhandler.h     |  56 +++++++++++++++
 indra/newview/llmaterialmgr.cpp       | 124 ++++++++++++++++++++++++----------
 indra/newview/llmaterialmgr.h         |  26 +++----
 indra/newview/llxmlrpctransaction.cpp |   6 +-
 14 files changed, 314 insertions(+), 151 deletions(-)
 create mode 100644 indra/llmessage/llhttpsdhandler.cpp
 create mode 100644 indra/llmessage/llhttpsdhandler.h

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/bufferarray.h b/indra/llcorehttp/bufferarray.h
index 9c2b991de6..1da807b0a6 100755
--- a/indra/llcorehttp/bufferarray.h
+++ b/indra/llcorehttp/bufferarray.h
@@ -131,6 +131,7 @@ protected:
 
 	container_t			mBlocks;
 	size_t				mLen;
+
 };  // end class BufferArray
 
 
diff --git a/indra/llcorehttp/httpheaders.cpp b/indra/llcorehttp/httpheaders.cpp
index 23ebea361c..73c92c8f10 100755
--- a/indra/llcorehttp/httpheaders.cpp
+++ b/indra/llcorehttp/httpheaders.cpp
@@ -105,7 +105,7 @@ void HttpHeaders::appendNormal(const char * header, size_t size)
 
 // Find from end to simulate a tradition of using single-valued
 // std::map for this in the past.
-const std::string * HttpHeaders::find(const char * name) const
+const std::string * HttpHeaders::find(const std::string &name) const
 {
 	const_reverse_iterator iend(rend());
 	for (const_reverse_iterator iter(rbegin()); iend != iter; ++iter)
diff --git a/indra/llcorehttp/httpheaders.h b/indra/llcorehttp/httpheaders.h
index c89d6af222..41832c4931 100755
--- a/indra/llcorehttp/httpheaders.h
+++ b/indra/llcorehttp/httpheaders.h
@@ -146,8 +146,12 @@ public:
 	//					a pointer to a std::string in the container.
 	//					Pointer is valid only for the lifetime of
 	//					the container or until container is modifed.
-	//
-	const std::string * find(const char * name) const;
+	
+	const std::string * find(const std::string &name) const;
+	const std::string * find(const char * name) const
+	{
+		return find(std::string(name));
+	}
 
 	// Count of headers currently in the list.
 	size_type size() const
diff --git a/indra/llcorehttp/httpresponse.cpp b/indra/llcorehttp/httpresponse.cpp
index c974395b0a..87e3426415 100755
--- a/indra/llcorehttp/httpresponse.cpp
+++ b/indra/llcorehttp/httpresponse.cpp
@@ -89,5 +89,9 @@ void HttpResponse::setHeaders(HttpHeaders * headers)
 	mHeaders = headers;
 }
 
+size_t HttpResponse::getBodySize() const
+{
+	return (mBufferArray) ? mBufferArray->size() : 0;
+}
 
 }   // end namespace LLCore
diff --git a/indra/llcorehttp/httpresponse.h b/indra/llcorehttp/httpresponse.h
index 01e9dd2bc6..c6b470ee3f 100755
--- a/indra/llcorehttp/httpresponse.h
+++ b/indra/llcorehttp/httpresponse.h
@@ -104,6 +104,10 @@ public:
 			return mBufferArray;
 		}
 
+	/// Safely get the size of the body buffer.  If the body buffer is missing
+	/// return 0 as the size.
+	size_t getBodySize() const;
+
 	/// Set the response data in the instance.  Will drop the reference
 	/// count to any existing data and increment the count of that passed
 	/// in.  It is legal to set the data to NULL.
diff --git a/indra/llmessage/CMakeLists.txt b/indra/llmessage/CMakeLists.txt
index 40eddcb0ab..c5b6024b89 100755
--- a/indra/llmessage/CMakeLists.txt
+++ b/indra/llmessage/CMakeLists.txt
@@ -49,6 +49,7 @@ set(llmessage_SOURCE_FILES
     llhttpclientadapter.cpp
     llhttpconstants.cpp
     llhttpnode.cpp
+	llhttpsdhandler.cpp
     llhttpsender.cpp
     llinstantmessage.cpp
     lliobuffer.cpp
@@ -144,6 +145,7 @@ set(llmessage_HEADER_FILES
     llhttpconstants.h
     llhttpnode.h
     llhttpnodeadapter.h
+	llhttpsdhandler.h
     llhttpsender.h
     llinstantmessage.h
     llinvite.h
diff --git a/indra/llmessage/llcorehttputil.cpp b/indra/llmessage/llcorehttputil.cpp
index ee80b0fd94..1a5a6fc75f 100644
--- a/indra/llmessage/llcorehttputil.cpp
+++ b/indra/llmessage/llcorehttputil.cpp
@@ -88,6 +88,32 @@ HttpHandle requestPostWithLLSD(HttpRequest * request,
 	return handle;
 }
 
+HttpHandle requestPutWithLLSD(HttpRequest * request,
+							   HttpRequest::policy_t policy_id,
+							   HttpRequest::priority_t priority,
+							   const std::string & url,
+							   const LLSD & body,
+							   HttpOptions * options,
+							   HttpHeaders * headers,
+							   HttpHandler * handler)
+{
+	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
+
+	BufferArray * ba = new BufferArray();
+	BufferArrayStream bas(ba);
+	LLSDSerialize::toXML(body, bas);
+
+	handle = request->requestPut(policy_id,
+		priority,
+		url,
+		ba,
+		options,
+		headers,
+		handler);
+	ba->release();
+	return handle;
+}
+
 
 std::string responseToString(LLCore::HttpResponse * response)
 {
diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index d40172bc7a..7c5a5aea61 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -109,6 +109,31 @@ LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest * request,
 									   LLCore::HttpHeaders * headers,
 									   LLCore::HttpHandler * handler);
 
+/// Issue a standard HttpRequest::requestPut() call but using
+/// and LLSD object as the request body.  Conventions are the
+/// same as with that method.  Caller is expected to provide
+/// an HttpHeaders object with a correct 'Content-Type:' header.
+/// One will not be provided by this call.
+///
+/// @return				If request is successfully issued, the
+///						HttpHandle representing the request.
+///						On error, LLCORE_HTTP_HANDLE_INVALID
+///						is returned and caller can fetch detailed
+///						status with the getStatus() method on the
+///						request object.  In case of error, no
+///						request is queued and caller may need to
+///						perform additional cleanup such as freeing
+///						a now-useless HttpHandler object.
+///
+LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest * request,
+	LLCore::HttpRequest::policy_t policy_id,
+	LLCore::HttpRequest::priority_t priority,
+	const std::string & url,
+	const LLSD & body,
+	LLCore::HttpOptions * options,
+	LLCore::HttpHeaders * headers,
+	LLCore::HttpHandler * handler);
+
 } // end namespace LLCoreHttpUtil
 
 
diff --git a/indra/llmessage/llcurl.h b/indra/llmessage/llcurl.h
index 295e9c9fe5..06b3ce45e1 100755
--- a/indra/llmessage/llcurl.h
+++ b/indra/llmessage/llcurl.h
@@ -309,7 +309,6 @@ private:
 	static void deleteAllFreeHandles();
 };
 
-#if 1
 class LLCurl::Multi
 {
 	LOG_CLASS(Multi);
@@ -380,7 +379,6 @@ private:
 	LLFrameTimer mIdleTimer ;
 	F32 mIdleTimeOut;
 };
-#endif
 
 class LLCurlThread : public LLQueuedThread
 {
@@ -419,103 +417,6 @@ private:
 	void cleanupMulti(LLCurl::Multi* multi) ;
 } ;
 
-#if 0
-class LLCurlRequest
-{
-public:
-	typedef std::vector<std::string> headers_t;
-	
-	LLCurlRequest();
-	~LLCurlRequest();
-
-	void get(const std::string& url, LLCurl::ResponderPtr responder);
-	bool getByteRange(const std::string& url, const headers_t& headers, S32 offset, S32 length, LLCurl::ResponderPtr responder);
-	bool post(const std::string& url, const headers_t& headers, const LLSD& data, LLCurl::ResponderPtr responder, S32 time_out = 0);
-	bool post(const std::string& url, const headers_t& headers, const std::string& data, LLCurl::ResponderPtr responder, S32 time_out = 0);
-	
-	S32  process();
-	S32  getQueued();
-
-private:
-	void addMulti();
-	LLCurl::Easy* allocEasy();
-	bool addEasy(LLCurl::Easy* easy);
-	
-private:
-	typedef std::set<LLCurl::Multi*> curlmulti_set_t;
-	curlmulti_set_t mMultiSet;
-	LLCurl::Multi* mActiveMulti;
-	S32 mActiveRequestCount;
-	BOOL mProcessing;
-};
-#endif
-
-#if 0
-//for texture fetch only
-class LLCurlTextureRequest : public LLCurlRequest
-{
-public:
-	LLCurlTextureRequest(S32 concurrency);
-	~LLCurlTextureRequest();
-
-	U32 getByteRange(const std::string& url, const headers_t& headers, S32 offset, S32 length, U32 pri, LLCurl::ResponderPtr responder, F32 delay_time = -1.f);
-	void nextRequests();
-	void completeRequest(S32 received_bytes);
-
-	void updatePriority(U32 handle, U32 pri);
-	void removeRequest(U32 handle);
-
-	U32 getTotalReceivedBits();
-	U32 getTotalIssuedRequests();
-	S32 getNumRequests();
-	bool isWaiting(U32 handle);
-	
-private:
-	LLMutex mMutex;
-	S32 mConcurrency;
-	S32 mInQueue; //request currently in queue.
-	U32 mHandleCounter;
-	U32 mTotalIssuedRequests;
-	U32 mTotalReceivedBits;
-
-	typedef struct _request_t
-	{
-		_request_t(U32 handle, const std::string& url, const headers_t& headers, S32 offset, S32 length, U32 pri, LLCurl::ResponderPtr responder) :
-				mHandle(handle), mUrl(url), mHeaders(headers), mOffset(offset), mLength(length), mPriority(pri), mResponder(responder), mStartTime(0.f)
-				{}
-
-		U32  mHandle;
-		std::string mUrl;
-		LLCurlRequest::headers_t mHeaders;
-		S32 mOffset;
-		S32 mLength;
-		LLCurl::ResponderPtr mResponder;
-		U32 mPriority;
-		F32 mStartTime; //start time to issue this request
-	} request_t;
-
-	struct request_compare
-	{
-		bool operator()(const request_t* lhs, const request_t* rhs) const
-		{
-			if(lhs->mPriority != rhs->mPriority)
-			{
-				return lhs->mPriority > rhs->mPriority; // higher priority in front of queue (set)
-			}
-			else
-			{
-				return (U32)lhs < (U32)rhs;
-			}
-		}
-	};
-
-	typedef std::set<request_t*, request_compare> req_queue_t;
-	req_queue_t mCachedRequests;
-	std::map<S32, request_t*> mRequestMap;
-
-	LLFrameTimer mGlobalTimer;
-};
-#endif 
 
 class LLCurlEasyRequest
 {
diff --git a/indra/llmessage/llhttpsdhandler.cpp b/indra/llmessage/llhttpsdhandler.cpp
new file mode 100644
index 0000000000..aa9801cebc
--- /dev/null
+++ b/indra/llmessage/llhttpsdhandler.cpp
@@ -0,0 +1,82 @@
+/**
+* @file llhttpsdhandler.h
+* @brief Public-facing declarations for the HttpHandler class
+*
+* $LicenseInfo:firstyear=2012&license=viewerlgpl$
+* Second Life Viewer Source Code
+* Copyright (C) 2012, 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 "llhttpconstants.h"
+
+#include "llhttpsdhandler.h"
+#include "httpresponse.h"
+#include "httpheaders.h"
+#include "llsd.h"
+#include "llsdserialize.h"
+#include "bufferstream.h"
+#include "llcorehttputil.h"
+
+//========================================================================
+LLHttpSDHandler::LLHttpSDHandler(const LLURI &uri):
+	mUri(uri)
+{
+
+}
+
+void LLHttpSDHandler::onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response)
+{
+	LLCore::HttpStatus status = response->getStatus();
+
+	if (!status)
+	{
+		this->onFailure(response, status);
+	}
+	else
+	{
+		LLSD resplsd;
+		const bool emit_parse_errors = false;
+
+		bool parsed = !((response->getBodySize() == 0) ||
+			!LLCoreHttpUtil::responseToLLSD(response, emit_parse_errors, resplsd));
+
+		if (!parsed) 
+		{
+			// Only emit a warning if we failed to parse when 'content-type' == 'application/llsd+xml'
+			LLCore::HttpHeaders::ptr_t headers(response->getHeaders());
+			const std::string *contentType = (headers) ? headers->find(HTTP_IN_HEADER_CONTENT_TYPE) : NULL;
+
+			if (contentType && (HTTP_CONTENT_LLSD_XML == *contentType))
+			{
+				std::string thebody = LLCoreHttpUtil::responseToString(response);
+
+				LL_WARNS() << "Failed to deserialize . " << getUri() << " [status:" << response->getStatus().toString() << "] "
+					<< " body: " << thebody << LL_ENDL;
+			}
+		}
+
+		this->onSuccess(response, resplsd);
+	}
+
+	// The handler must destroy itself when it is done.
+	delete this;
+}
+
diff --git a/indra/llmessage/llhttpsdhandler.h b/indra/llmessage/llhttpsdhandler.h
new file mode 100644
index 0000000000..7b7da61b3c
--- /dev/null
+++ b/indra/llmessage/llhttpsdhandler.h
@@ -0,0 +1,56 @@
+/**
+* @file llhttpsdhandler.h
+* @brief Public-facing declarations for the HttpHandler class
+*
+* $LicenseInfo:firstyear=2012&license=viewerlgpl$
+* Second Life Viewer Source Code
+* Copyright (C) 2012, 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	_LLHTTPSDHANDLER_H_
+#define	_LLHTTPSDHANDLER_H_
+#include "httpcommon.h"
+#include "httphandler.h"
+#include "lluri.h"
+
+/// 
+///
+class LLHttpSDHandler : public LLCore::HttpHandler
+{
+public:
+	LLHttpSDHandler(const LLURI &uri);
+
+	virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);
+	
+	inline const LLURI &getUri() const
+	{
+		return mUri;
+	}
+
+protected:
+	virtual void onSuccess(LLCore::HttpResponse * response, LLSD &content) = 0;
+	virtual void onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status) = 0;
+
+private:
+	LLURI	mUri;
+};
+
+
+#endif
\ No newline at end of file
diff --git a/indra/newview/llmaterialmgr.cpp b/indra/newview/llmaterialmgr.cpp
index a1f6a01aa0..f43efd75b8 100755
--- a/indra/newview/llmaterialmgr.cpp
+++ b/indra/newview/llmaterialmgr.cpp
@@ -36,6 +36,10 @@
 #include "llviewerobjectlist.h"
 #include "llviewerregion.h"
 #include "llworld.h"
+#include "llhttpsdhandler.h"
+#include "httpcommon.h"
+#include "httpheaders.h"
+#include "llcorehttputil.h"
 
 /**
  * Materials cap parameters
@@ -59,56 +63,51 @@
 #define MATERIALS_PUT_THROTTLE_SECS               1.f
 #define MATERIALS_PUT_MAX_ENTRIES                 50
 
-/**
- * LLMaterialsResponder helper class
- */
 
-class LLMaterialsResponder : public LLHTTPClient::Responder
+
+class LLMaterialHttpHandler : public LLHttpSDHandler
 {
-public:
-	typedef boost::function<void (bool, const LLSD&)> CallbackFunction;
+public: 
+	typedef boost::function<void(bool, const LLSD&)> CallbackFunction;
+	typedef boost::shared_ptr<LLMaterialHttpHandler> ptr_t;
+
+	LLMaterialHttpHandler(const std::string& method, const std::string& capabilityURL, CallbackFunction cback);
 
-	LLMaterialsResponder(const std::string& pMethod, const std::string& pCapabilityURL, CallbackFunction pCallback);
-	virtual ~LLMaterialsResponder();
+	virtual ~LLMaterialHttpHandler();
 
-	virtual void httpSuccess();
-	virtual void httpFailure();
+protected:
+	virtual void onSuccess(LLCore::HttpResponse * response, LLSD &content);
+	virtual void onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status);
 
 private:
 	std::string      mMethod;
-	std::string      mCapabilityURL;
 	CallbackFunction mCallback;
 };
 
-LLMaterialsResponder::LLMaterialsResponder(const std::string& pMethod, const std::string& pCapabilityURL, CallbackFunction pCallback)
-	: LLHTTPClient::Responder()
-	, mMethod(pMethod)
-	, mCapabilityURL(pCapabilityURL)
-	, mCallback(pCallback)
+LLMaterialHttpHandler::LLMaterialHttpHandler(const std::string& method, const std::string& capabilityURL, CallbackFunction cback):
+	LLHttpSDHandler(capabilityURL),
+	mMethod(method),
+	mCallback(cback)
 {
+
 }
 
-LLMaterialsResponder::~LLMaterialsResponder()
+LLMaterialHttpHandler::~LLMaterialHttpHandler()
 {
 }
 
-void LLMaterialsResponder::httpSuccess()
+void LLMaterialHttpHandler::onSuccess(LLCore::HttpResponse * response, LLSD &content)
 {
-	const LLSD& pContent = getContent();
-
 	LL_DEBUGS("Materials") << LL_ENDL;
-	mCallback(true, pContent);
+	mCallback(true, content);
 }
 
-void LLMaterialsResponder::httpFailure()
+void LLMaterialHttpHandler::onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status)
 {
-	U32 pStatus = (U32) getStatus();
-	const std::string& pReason = getReason();
-	
 	LL_WARNS("Materials")
 		<< "\n--------------------------------------------------------------------------\n"
-		<< mMethod << " Error[" << pStatus << "] cannot access cap '" << MATERIALS_CAPABILITY_NAME
-		<< "'\n  with url '" << mCapabilityURL	<< "' because " << pReason 
+		<< mMethod << " Error[" << status.toULong() << "] cannot access cap '" << MATERIALS_CAPABILITY_NAME
+		<< "'\n  with url '" << getUri() << "' because " << status.toString()
 		<< "\n--------------------------------------------------------------------------"
 		<< LL_ENDL;
 
@@ -116,12 +115,16 @@ void LLMaterialsResponder::httpFailure()
 	mCallback(false, emptyResult);
 }
 
+
+
 /**
  * LLMaterialMgr class
  */
 
 LLMaterialMgr::LLMaterialMgr()
 {
+	mRequest = LLCore::HttpRequest::ptr_t(new LLCore::HttpRequest());
+
 	mMaterials.insert(std::pair<LLMaterialID, LLMaterialPtr>(LLMaterialID::null, LLMaterialPtr(NULL)));
 	gIdleCallbacks.addFunction(&LLMaterialMgr::onIdle, NULL);
 	LLWorld::instance().setRegionRemovedCallback(boost::bind(&LLMaterialMgr::onRegionRemoved, this, _1));
@@ -554,6 +557,8 @@ void LLMaterialMgr::onIdle(void*)
 	{
 		instancep->processPutQueue();
 	}
+
+	instancep->mRequest->update(0L);
 }
 
 void LLMaterialMgr::processGetQueue()
@@ -629,10 +634,28 @@ void LLMaterialMgr::processGetQueue()
 		LLSD postData = LLSD::emptyMap();
 		postData[MATERIALS_CAP_ZIP_FIELD] = materialBinary;
 
-		LLHTTPClient::ResponderPtr materialsResponder = new LLMaterialsResponder("POST", capURL, boost::bind(&LLMaterialMgr::onGetResponse, this, _1, _2, region_id));
-		LL_DEBUGS("Materials") << "POSTing to region '" << regionp->getName() << "' at '"<< capURL << " for " << materialsData.size() << " materials." 
+		LLMaterialHttpHandler * handler = 
+				new LLMaterialHttpHandler("POST", capURL,
+				boost::bind(&LLMaterialMgr::onGetResponse, this, _1, _2, region_id)
+				);
+
+		LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false);
+
+		LL_DEBUGS("Materials") << "POSTing to region '" << regionp->getName() << "' at '" << capURL << " for " << materialsData.size() << " materials."
 			<< "\ndata: " << ll_pretty_print_sd(materialsData) << LL_ENDL;
-		LLHTTPClient::post(capURL, postData, materialsResponder);
+
+		LLCore::HttpHandle handle = LLCoreHttpUtil::requestPutWithLLSD(mRequest.get(), 
+				LLCore::HttpRequest::DEFAULT_POLICY_ID, 0, capURL, 
+				postData, NULL, headers.get(), handler);
+
+		if (handle == LLCORE_HTTP_HANDLE_INVALID)
+		{
+			delete handler;
+			LLCore::HttpStatus status = mRequest->getStatus();
+			LL_ERRS("Meterials") << "Failed to execute material POST. Status = " <<
+				status.toULong() << "\"" << status.toString() << "\"" << LL_ENDL;
+		}
+
 		regionp->resetMaterialsCapThrottle();
 	}
 }
@@ -667,8 +690,24 @@ void LLMaterialMgr::processGetAllQueue()
 		}
 
 		LL_DEBUGS("Materials") << "GET all for region " << region_id << "url " << capURL << LL_ENDL;
-		LLHTTPClient::ResponderPtr materialsResponder = new LLMaterialsResponder("GET", capURL, boost::bind(&LLMaterialMgr::onGetAllResponse, this, _1, _2, *itRegion));
-		LLHTTPClient::get(capURL, materialsResponder);
+		LLMaterialHttpHandler *handler = 
+			new LLMaterialHttpHandler("GET", capURL,
+			boost::bind(&LLMaterialMgr::onGetAllResponse, this, _1, _2, *itRegion)
+			);
+
+		LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false);
+
+		LLCore::HttpHandle handle = mRequest->requestGet(LLCore::HttpRequest::DEFAULT_POLICY_ID, 0,
+				capURL, NULL, headers.get(), handler);
+
+		if (handle == LLCORE_HTTP_HANDLE_INVALID)
+		{
+			delete handler;
+			LLCore::HttpStatus status = mRequest->getStatus();
+			LL_ERRS("Meterials") << "Failed to execute material GET. Status = " <<
+				status.toULong() << "\"" << status.toString() << "\"" << LL_ENDL;
+		}
+
 		regionp->resetMaterialsCapThrottle();
 		mGetAllPending.insert(std::pair<LLUUID, F64>(region_id, LLFrameTimer::getTotalSeconds()));
 		mGetAllQueue.erase(itRegion);	// Invalidates region_id
@@ -755,8 +794,25 @@ void LLMaterialMgr::processPutQueue()
 			putData[MATERIALS_CAP_ZIP_FIELD] = materialBinary;
 
 			LL_DEBUGS("Materials") << "put for " << itRequest->second.size() << " faces to region " << itRequest->first->getName() << LL_ENDL;
-			LLHTTPClient::ResponderPtr materialsResponder = new LLMaterialsResponder("PUT", capURL, boost::bind(&LLMaterialMgr::onPutResponse, this, _1, _2));
-			LLHTTPClient::put(capURL, putData, materialsResponder);
+
+			LLMaterialHttpHandler * handler =
+					new LLMaterialHttpHandler("PUT", capURL,
+					boost::bind(&LLMaterialMgr::onPutResponse, this, _1, _2)
+					);
+
+			LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false);
+
+			LLCore::HttpHandle handle = LLCoreHttpUtil::requestPutWithLLSD(mRequest.get(), LLCore::HttpRequest::DEFAULT_POLICY_ID, 0,
+				capURL, putData, NULL, headers.get(), handler);
+
+			if (handle == LLCORE_HTTP_HANDLE_INVALID)
+			{
+				delete handler;
+				LLCore::HttpStatus status = mRequest->getStatus();
+				LL_ERRS("Meterials") << "Failed to execute material PUT. Status = " << 
+					status.toULong() << "\"" << status.toString() << "\"" << LL_ENDL;
+			}
+
 			regionp->resetMaterialsCapThrottle();
 		}
 		else
diff --git a/indra/newview/llmaterialmgr.h b/indra/newview/llmaterialmgr.h
index e83f1f4e01..0904c9b2c4 100644
--- a/indra/newview/llmaterialmgr.h
+++ b/indra/newview/llmaterialmgr.h
@@ -30,6 +30,7 @@
 #include "llmaterial.h"
 #include "llmaterialid.h"
 #include "llsingleton.h"
+#include "httprequest.h"
 
 class LLViewerRegion;
 
@@ -56,7 +57,7 @@ public:
 	void put(const LLUUID& object_id, const U8 te, const LLMaterial& material);
 	void remove(const LLUUID& object_id, const U8 te);
 
-protected:
+private:
 	void clearGetQueues(const LLUUID& region_id);
 	bool isGetPending(const LLUUID& region_id, const LLMaterialID& material_id) const;
 	bool isGetAllPending(const LLUUID& region_id) const;
@@ -72,14 +73,15 @@ protected:
 	void onPutResponse(bool success, const LLSD& content);
 	void onRegionRemoved(LLViewerRegion* regionp);
 
-protected:
+private:
 	typedef std::set<LLMaterialID> material_queue_t;
 	typedef std::map<LLUUID, material_queue_t> get_queue_t;
-	get_queue_t        mGetQueue;
 	typedef std::pair<const LLUUID, LLMaterialID> pending_material_t;
 	typedef std::map<const pending_material_t, F64> get_pending_map_t;
-	get_pending_map_t  mGetPending;
 	typedef std::map<LLMaterialID, get_callback_t*> get_callback_map_t;
+
+	get_queue_t        mGetQueue;
+	get_pending_map_t  mGetPending;
 	get_callback_map_t mGetCallbacks;
 
 	// struct for TE-specific material ID query
@@ -109,22 +111,22 @@ protected:
 	};
 
 	typedef boost::unordered_map<TEMaterialPair, get_callback_te_t*, TEMaterialPairHasher> get_callback_te_map_t;
-	get_callback_te_map_t mGetTECallbacks;
-
 	typedef std::set<LLUUID> getall_queue_t;
-	getall_queue_t        mGetAllQueue;
-	getall_queue_t        mGetAllRequested;
 	typedef std::map<LLUUID, F64> getall_pending_map_t;
-	getall_pending_map_t  mGetAllPending;
 	typedef std::map<LLUUID, getall_callback_t*> getall_callback_map_t;
-	getall_callback_map_t mGetAllCallbacks;
-
 	typedef std::map<U8, LLMaterial> facematerial_map_t;
 	typedef std::map<LLUUID, facematerial_map_t> put_queue_t;
-	put_queue_t mPutQueue;
 
+	get_callback_te_map_t mGetTECallbacks;
+	getall_queue_t        mGetAllQueue;
+	getall_queue_t        mGetAllRequested;
+	getall_pending_map_t  mGetAllPending;
+	getall_callback_map_t mGetAllCallbacks;
+	put_queue_t mPutQueue;
 	material_map_t mMaterials;
 
+	LLCore::HttpRequest::ptr_t mRequest;
+
 	U32 getMaxEntries(const LLViewerRegion* regionp);
 };
 
diff --git a/indra/newview/llxmlrpctransaction.cpp b/indra/newview/llxmlrpctransaction.cpp
index e4e63afa16..2270b840a0 100755
--- a/indra/newview/llxmlrpctransaction.cpp
+++ b/indra/newview/llxmlrpctransaction.cpp
@@ -312,7 +312,6 @@ LLXMLRPCTransaction::Impl::Impl(const std::string& uri,
 	: mHttpRequest(0),
 	  mStatus(LLXMLRPCTransaction::StatusNotStarted),
 	  mURI(uri),
-//	  mRequestText(0), 
 	  mResponse(0)
 {
 	init(request, useGzip);
@@ -324,7 +323,6 @@ LLXMLRPCTransaction::Impl::Impl(const std::string& uri,
 	: mHttpRequest(0),
 	  mStatus(LLXMLRPCTransaction::StatusNotStarted),
 	  mURI(uri),
-//	  mRequestText(0), 
 	  mResponse(0)
 {
 	XMLRPC_REQUEST request = XMLRPC_RequestNew();
@@ -485,12 +483,14 @@ void LLXMLRPCTransaction::Impl::setHttpStatus(const LLCore::HttpStatus &status)
 	CURLcode code = static_cast<CURLcode>(status.toULong());
 	std::string message;
 	std::string uri = "http://secondlife.com/community/support.php";
+	LLURI failuri(mURI);
+
 
 	switch (code)
 	{
 	case CURLE_COULDNT_RESOLVE_HOST:
 		message =
-			"DNS could not resolve the host name.\n"
+			std::string("DNS could not resolve the host name(") + failuri.hostName() + ").\n"
 			"Please verify that you can connect to the www.secondlife.com\n"
 			"web site.  If you can, but continue to receive this error,\n"
 			"please go to the support section and report this problem.";
-- 
cgit v1.3


From 9d676ce5b97d7ce09630d7d6ab8abd562b958cae Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Fri, 20 Mar 2015 13:16:25 -0700
Subject: Clean up and use policies for Material transfer.

---
 indra/llcorehttp/_httpinternal.h   |  5 ++--
 indra/llmessage/llcorehttputil.cpp | 25 +++++++++++++++++
 indra/llmessage/llcorehttputil.h   | 18 +++++++++++++
 indra/newview/llappcorehttp.cpp    |  7 +++++
 indra/newview/llappcorehttp.h      | 11 ++++++++
 indra/newview/llmaterialmgr.cpp    | 55 +++++++++++++++++++++++---------------
 indra/newview/llmaterialmgr.h      | 45 ++++++++++++++++++-------------
 7 files changed, 124 insertions(+), 42 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/_httpinternal.h b/indra/llcorehttp/_httpinternal.h
index a2a60ca056..79c89d6c92 100755
--- a/indra/llcorehttp/_httpinternal.h
+++ b/indra/llcorehttp/_httpinternal.h
@@ -104,8 +104,9 @@ namespace LLCore
 {
 
 // Maxium number of policy classes that can be defined.
-// *TODO:  Currently limited to the default class + 1, extend.
-const int HTTP_POLICY_CLASS_LIMIT = 8;
+// *TODO:  Currently limited to the default class + 1, extend. 
+// (TSN: should this be more dynamically sized.  Is there a reason to hard limit the number of policies?)
+const int HTTP_POLICY_CLASS_LIMIT = 32;
 
 // Debug/informational tracing.  Used both
 // as a global option and in per-request traces.
diff --git a/indra/llmessage/llcorehttputil.cpp b/indra/llmessage/llcorehttputil.cpp
index 1a5a6fc75f..366a0b9460 100644
--- a/indra/llmessage/llcorehttputil.cpp
+++ b/indra/llmessage/llcorehttputil.cpp
@@ -88,6 +88,19 @@ HttpHandle requestPostWithLLSD(HttpRequest * request,
 	return handle;
 }
 
+HttpHandle requestPostWithLLSD(HttpRequest::ptr_t & request,
+	HttpRequest::policy_t policy_id,
+	HttpRequest::priority_t priority,
+	const std::string & url,
+	const LLSD & body,
+	HttpOptions::ptr_t & options,
+	HttpHeaders::ptr_t & headers,
+	HttpHandler * handler)
+{
+	return requestPostWithLLSD(request.get(), policy_id, priority,
+		url, body, options.get(), headers.get(), handler);
+}
+
 HttpHandle requestPutWithLLSD(HttpRequest * request,
 							   HttpRequest::policy_t policy_id,
 							   HttpRequest::priority_t priority,
@@ -114,6 +127,18 @@ HttpHandle requestPutWithLLSD(HttpRequest * request,
 	return handle;
 }
 
+HttpHandle requestPutWithLLSD(HttpRequest::ptr_t & request,
+	HttpRequest::policy_t policy_id,
+	HttpRequest::priority_t priority,
+	const std::string & url,
+	const LLSD & body,
+	HttpOptions::ptr_t & options,
+	HttpHeaders::ptr_t & headers,
+	HttpHandler * handler)
+{
+	return requestPutWithLLSD(request.get(), policy_id, priority,
+		url, body, options.get(), headers.get(), handler);
+}
 
 std::string responseToString(LLCore::HttpResponse * response)
 {
diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 7c5a5aea61..8e26f413fe 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -109,6 +109,15 @@ LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest * request,
 									   LLCore::HttpHeaders * headers,
 									   LLCore::HttpHandler * handler);
 
+LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & request,
+	LLCore::HttpRequest::policy_t policy_id,
+	LLCore::HttpRequest::priority_t priority,
+	const std::string & url,
+	const LLSD & body,
+	LLCore::HttpOptions::ptr_t & options,
+	LLCore::HttpHeaders::ptr_t & headers,
+	LLCore::HttpHandler * handler);
+
 /// Issue a standard HttpRequest::requestPut() call but using
 /// and LLSD object as the request body.  Conventions are the
 /// same as with that method.  Caller is expected to provide
@@ -134,6 +143,15 @@ LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest * request,
 	LLCore::HttpHeaders * headers,
 	LLCore::HttpHandler * handler);
 
+LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
+	LLCore::HttpRequest::policy_t policy_id,
+	LLCore::HttpRequest::priority_t priority,
+	const std::string & url,
+	const LLSD & body,
+	LLCore::HttpOptions::ptr_t & options,
+	LLCore::HttpHeaders::ptr_t & headers,
+	LLCore::HttpHandler * handler);
+
 } // end namespace LLCoreHttpUtil
 
 
diff --git a/indra/newview/llappcorehttp.cpp b/indra/newview/llappcorehttp.cpp
index dd39b9a959..420d37369f 100755
--- a/indra/newview/llappcorehttp.cpp
+++ b/indra/newview/llappcorehttp.cpp
@@ -97,6 +97,11 @@ static const struct
 		4,		1,		4,		0,		false,
 		"",
 		"inventory"
+	},
+	{ // AP_MATERIALS
+		2,		1,		8,		0,		false,
+		"RenderMaterials",
+		"material manager requests"
 	}
 };
 
@@ -195,6 +200,8 @@ void LLAppCoreHttp::init()
 		}
 
 		mHttpClasses[app_policy].mPolicy = LLCore::HttpRequest::createPolicyClass();
+		// We have run out of available HTTP policies. Adjust HTTP_POLICY_CLASS_LIMIT in _httpinternal.h
+		llassert(mHttpClasses[app_policy].mPolicy != LLCore::HttpRequest::INVALID_POLICY_ID);
 		if (! mHttpClasses[app_policy].mPolicy)
 		{
 			// Use default policy (but don't accidentally modify default)
diff --git a/indra/newview/llappcorehttp.h b/indra/newview/llappcorehttp.h
index 9616354093..b636c3b43c 100755
--- a/indra/newview/llappcorehttp.h
+++ b/indra/newview/llappcorehttp.h
@@ -164,6 +164,17 @@ public:
 		/// Pipelined:       no
 		AP_INVENTORY,
 		AP_REPORTING = AP_INVENTORY,	// Piggy-back on inventory
+
+		/// Material resource requests and puts.  
+		///
+		/// Destination:     simhost:12043
+		/// Protocol:        https:
+		/// Transfer size:   KB
+		/// Long poll:       no
+		/// Concurrency:     low
+		/// Request rate:    low
+		/// Pipelined:       no
+		AP_MATERIALS,
 		
 		AP_COUNT						// Must be last
 	};
diff --git a/indra/newview/llmaterialmgr.cpp b/indra/newview/llmaterialmgr.cpp
index f43efd75b8..b4ebe4adb1 100755
--- a/indra/newview/llmaterialmgr.cpp
+++ b/indra/newview/llmaterialmgr.cpp
@@ -38,7 +38,6 @@
 #include "llworld.h"
 #include "llhttpsdhandler.h"
 #include "httpcommon.h"
-#include "httpheaders.h"
 #include "llcorehttputil.h"
 
 /**
@@ -120,10 +119,29 @@ void LLMaterialHttpHandler::onFailure(LLCore::HttpResponse * response, LLCore::H
 /**
  * LLMaterialMgr class
  */
-
-LLMaterialMgr::LLMaterialMgr()
+LLMaterialMgr::LLMaterialMgr():
+	mGetQueue(),
+	mGetPending(),
+	mGetCallbacks(),
+	mGetTECallbacks(),
+	mGetAllQueue(),
+	mGetAllRequested(),
+	mGetAllPending(),
+	mGetAllCallbacks(),
+	mPutQueue(),
+	mMaterials(),
+	mHttpRequest(NULL),
+	mHttpHeaders(NULL),
+	mHttpOptions(NULL),
+	mHttpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID),
+	mHttpPriority(0)
 {
-	mRequest = LLCore::HttpRequest::ptr_t(new LLCore::HttpRequest());
+	LLAppCoreHttp & app_core_http(LLAppViewer::instance()->getAppCoreHttp());
+
+	mHttpRequest = LLCore::HttpRequest::ptr_t(new LLCore::HttpRequest());
+	mHttpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false);
+	mHttpOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false);
+	mHttpPolicy = app_core_http.getPolicy(LLAppCoreHttp::AP_MATERIALS);
 
 	mMaterials.insert(std::pair<LLMaterialID, LLMaterialPtr>(LLMaterialID::null, LLMaterialPtr(NULL)));
 	gIdleCallbacks.addFunction(&LLMaterialMgr::onIdle, NULL);
@@ -558,7 +576,7 @@ void LLMaterialMgr::onIdle(void*)
 		instancep->processPutQueue();
 	}
 
-	instancep->mRequest->update(0L);
+	instancep->mHttpRequest->update(0L);
 }
 
 void LLMaterialMgr::processGetQueue()
@@ -639,19 +657,17 @@ void LLMaterialMgr::processGetQueue()
 				boost::bind(&LLMaterialMgr::onGetResponse, this, _1, _2, region_id)
 				);
 
-		LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false);
-
 		LL_DEBUGS("Materials") << "POSTing to region '" << regionp->getName() << "' at '" << capURL << " for " << materialsData.size() << " materials."
 			<< "\ndata: " << ll_pretty_print_sd(materialsData) << LL_ENDL;
 
-		LLCore::HttpHandle handle = LLCoreHttpUtil::requestPutWithLLSD(mRequest.get(), 
-				LLCore::HttpRequest::DEFAULT_POLICY_ID, 0, capURL, 
-				postData, NULL, headers.get(), handler);
+		LLCore::HttpHandle handle = LLCoreHttpUtil::requestPutWithLLSD(mHttpRequest, 
+				mHttpPolicy, mHttpPriority, capURL, 
+				postData, mHttpOptions, mHttpHeaders, handler);
 
 		if (handle == LLCORE_HTTP_HANDLE_INVALID)
 		{
 			delete handler;
-			LLCore::HttpStatus status = mRequest->getStatus();
+			LLCore::HttpStatus status = mHttpRequest->getStatus();
 			LL_ERRS("Meterials") << "Failed to execute material POST. Status = " <<
 				status.toULong() << "\"" << status.toString() << "\"" << LL_ENDL;
 		}
@@ -695,15 +711,13 @@ void LLMaterialMgr::processGetAllQueue()
 			boost::bind(&LLMaterialMgr::onGetAllResponse, this, _1, _2, *itRegion)
 			);
 
-		LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false);
-
-		LLCore::HttpHandle handle = mRequest->requestGet(LLCore::HttpRequest::DEFAULT_POLICY_ID, 0,
-				capURL, NULL, headers.get(), handler);
+		LLCore::HttpHandle handle = mHttpRequest->requestGet(mHttpPolicy, mHttpPriority, capURL,
+				mHttpOptions.get(), mHttpHeaders.get(), handler);
 
 		if (handle == LLCORE_HTTP_HANDLE_INVALID)
 		{
 			delete handler;
-			LLCore::HttpStatus status = mRequest->getStatus();
+			LLCore::HttpStatus status = mHttpRequest->getStatus();
 			LL_ERRS("Meterials") << "Failed to execute material GET. Status = " <<
 				status.toULong() << "\"" << status.toString() << "\"" << LL_ENDL;
 		}
@@ -800,15 +814,14 @@ void LLMaterialMgr::processPutQueue()
 					boost::bind(&LLMaterialMgr::onPutResponse, this, _1, _2)
 					);
 
-			LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false);
-
-			LLCore::HttpHandle handle = LLCoreHttpUtil::requestPutWithLLSD(mRequest.get(), LLCore::HttpRequest::DEFAULT_POLICY_ID, 0,
-				capURL, putData, NULL, headers.get(), handler);
+			LLCore::HttpHandle handle = LLCoreHttpUtil::requestPutWithLLSD(
+				mHttpRequest, mHttpPolicy, mHttpPriority, capURL,
+				putData, mHttpOptions, mHttpHeaders, handler);
 
 			if (handle == LLCORE_HTTP_HANDLE_INVALID)
 			{
 				delete handler;
-				LLCore::HttpStatus status = mRequest->getStatus();
+				LLCore::HttpStatus status = mHttpRequest->getStatus();
 				LL_ERRS("Meterials") << "Failed to execute material PUT. Status = " << 
 					status.toULong() << "\"" << status.toString() << "\"" << LL_ENDL;
 			}
diff --git a/indra/newview/llmaterialmgr.h b/indra/newview/llmaterialmgr.h
index 0904c9b2c4..ef202d24ba 100644
--- a/indra/newview/llmaterialmgr.h
+++ b/indra/newview/llmaterialmgr.h
@@ -31,6 +31,8 @@
 #include "llmaterialid.h"
 #include "llsingleton.h"
 #include "httprequest.h"
+#include "httpheaders.h"
+#include "httpoptions.h"
 
 class LLViewerRegion;
 
@@ -74,16 +76,6 @@ private:
 	void onRegionRemoved(LLViewerRegion* regionp);
 
 private:
-	typedef std::set<LLMaterialID> material_queue_t;
-	typedef std::map<LLUUID, material_queue_t> get_queue_t;
-	typedef std::pair<const LLUUID, LLMaterialID> pending_material_t;
-	typedef std::map<const pending_material_t, F64> get_pending_map_t;
-	typedef std::map<LLMaterialID, get_callback_t*> get_callback_map_t;
-
-	get_queue_t        mGetQueue;
-	get_pending_map_t  mGetPending;
-	get_callback_map_t mGetCallbacks;
-
 	// struct for TE-specific material ID query
 	class TEMaterialPair
 	{
@@ -110,6 +102,13 @@ private:
 		bool   operator()(const TEMaterialPair& left, const TEMaterialPair& right) const { return left < right; }
 	};
 
+	typedef std::set<LLMaterialID> material_queue_t;
+	typedef std::map<LLUUID, material_queue_t> get_queue_t;
+	typedef std::pair<const LLUUID, LLMaterialID> pending_material_t;
+	typedef std::map<const pending_material_t, F64> get_pending_map_t;
+	typedef std::map<LLMaterialID, get_callback_t*> get_callback_map_t;
+
+
 	typedef boost::unordered_map<TEMaterialPair, get_callback_te_t*, TEMaterialPairHasher> get_callback_te_map_t;
 	typedef std::set<LLUUID> getall_queue_t;
 	typedef std::map<LLUUID, F64> getall_pending_map_t;
@@ -117,15 +116,23 @@ private:
 	typedef std::map<U8, LLMaterial> facematerial_map_t;
 	typedef std::map<LLUUID, facematerial_map_t> put_queue_t;
 
-	get_callback_te_map_t mGetTECallbacks;
-	getall_queue_t        mGetAllQueue;
-	getall_queue_t        mGetAllRequested;
-	getall_pending_map_t  mGetAllPending;
-	getall_callback_map_t mGetAllCallbacks;
-	put_queue_t mPutQueue;
-	material_map_t mMaterials;
-
-	LLCore::HttpRequest::ptr_t mRequest;
+	get_queue_t				mGetQueue;
+	get_pending_map_t		mGetPending;
+	get_callback_map_t		mGetCallbacks;
+
+	get_callback_te_map_t	mGetTECallbacks;
+	getall_queue_t			mGetAllQueue;
+	getall_queue_t			mGetAllRequested;
+	getall_pending_map_t	mGetAllPending;
+	getall_callback_map_t	mGetAllCallbacks;
+	put_queue_t				mPutQueue;
+	material_map_t			mMaterials;
+
+	LLCore::HttpRequest::ptr_t		mHttpRequest;
+	LLCore::HttpHeaders::ptr_t		mHttpHeaders;
+	LLCore::HttpOptions::ptr_t		mHttpOptions;
+	LLCore::HttpRequest::policy_t	mHttpPolicy;
+	LLCore::HttpRequest::priority_t	mHttpPriority;
 
 	U32 getMaxEntries(const LLViewerRegion* regionp);
 };
-- 
cgit v1.3


From 3b923962f8e0a065052f40d029bce42a6fe37e68 Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Mon, 23 Mar 2015 12:23:35 -0700
Subject: Reogranized some headers for GCC added <memory> to the
 linden_common.h for shared_ptr

---
 indra/llcommon/linden_common.h | 1 +
 indra/llcorehttp/bufferarray.h | 1 +
 2 files changed, 2 insertions(+)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcommon/linden_common.h b/indra/llcommon/linden_common.h
index 5cfcdab41c..e5a913a6a9 100755
--- a/indra/llcommon/linden_common.h
+++ b/indra/llcommon/linden_common.h
@@ -51,6 +51,7 @@
 #include <cstdlib>
 #include <ctime>
 #include <iosfwd>
+#include <memory>
 
 // Linden only libs in alpha-order other than stdtypes.h
 // *NOTE: Please keep includes here to a minimum, see above.
diff --git a/indra/llcorehttp/bufferarray.h b/indra/llcorehttp/bufferarray.h
index 1da807b0a6..076f341736 100755
--- a/indra/llcorehttp/bufferarray.h
+++ b/indra/llcorehttp/bufferarray.h
@@ -30,6 +30,7 @@
 
 #include <cstdlib>
 #include <vector>
+#include "boost/intrusive_ptr.hpp"
 
 #include "_refcounted.h"
 
-- 
cgit v1.3


From 530bf560b2c2c9bf534bb3ba4f588c72a59be703 Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Mon, 23 Mar 2015 13:28:24 -0700
Subject: Continue with gcc issues.

---
 indra/llcorehttp/httpcommon.cpp | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/httpcommon.cpp b/indra/llcorehttp/httpcommon.cpp
index 1aece696e3..c201400423 100755
--- a/indra/llcorehttp/httpcommon.cpp
+++ b/indra/llcorehttp/httpcommon.cpp
@@ -131,18 +131,18 @@ std::string HttpStatus::toString() const
 	{
 		return std::string("");
 	}
-	switch (mDetails->mType)
+	switch (this->mDetails->mType)
 	{
 	case EXT_CURL_EASY:
-		return std::string(curl_easy_strerror(CURLcode(mDetails->mStatus)));
+		return std::string(curl_easy_strerror(CURLcode(this->mDetails->mStatus)));
 
 	case EXT_CURL_MULTI:
-		return std::string(curl_multi_strerror(CURLMcode(mDetails->mStatus)));
+		return std::string(curl_multi_strerror(CURLMcode(this->mDetails->mStatus)));
 
 	case LLCORE:
-		if (mDetails->mStatus >= 0 && mDetails->mStatus < llcore_errors_count)
+		if (this->mDetails->mStatus >= 0 && this->mDetails->mStatus < llcore_errors_count)
 		{
-			return std::string(llcore_errors[mDetails->mStatus]);
+			return std::string(llcore_errors[this->mDetails->mStatus]);
 		}
 		break;
 
@@ -154,7 +154,7 @@ std::string HttpStatus::toString() const
 			while (true)
 			{
 				int at((bottom + top) / 2);
-				if (mDetails->mType == http_errors[at].mCode)
+				if (this->mDetails->mType == http_errors[at].mCode)
 				{
 					return std::string(http_errors[at].mText);
 				}
@@ -162,7 +162,7 @@ std::string HttpStatus::toString() const
 				{
 					break;
 				}
-				else if (mDetails->mType < http_errors[at].mCode)
+				else if (this->mDetails->mType < http_errors[at].mCode)
 				{
 					top = at;
 				}
@@ -182,9 +182,9 @@ std::string HttpStatus::toTerseString() const
 {
 	std::ostringstream result;
 
-	unsigned int error_value((unsigned short)mDetails->mStatus);
+	unsigned int error_value((unsigned short)(this->mDetails->mStatus));
 	
-	switch (mDetails->mType)
+	switch (this->mDetails->mType)
 	{
 	case EXT_CURL_EASY:
 		result << "Easy_";
@@ -202,7 +202,7 @@ std::string HttpStatus::toTerseString() const
 		if (isHttpStatus())
 		{
 			result << "Http_";
-			error_value = mDetails->mType;
+			error_value = this->mDetails->mType;
 		}
 		else
 		{
@@ -244,7 +244,7 @@ bool HttpStatus::isRetryable() const
 	// Disable the '*this == inv_status' test and look for 'Core_9'
 	// failures in log files.
 
-	return ((isHttpStatus() && mDetails->mType >= 499 && mDetails->mType <= 599) ||	// Include special 499 in retryables
+	return ((isHttpStatus() && this->mDetails->mType >= 499 && this->mDetails->mType <= 599) ||	// Include special 499 in retryables
 			*this == cant_connect ||	// Connection reset/endpoint problems
 			*this == cant_res_proxy ||	// DNS problems
 			*this == cant_res_host ||	// DNS problems
-- 
cgit v1.3


From e7a1e6198b9bf1b42d60bff9559494887e22d5e7 Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Mon, 23 Mar 2015 13:39:33 -0700
Subject: Slightly cleaner than this-> ing everythnig.

---
 indra/llcorehttp/httpcommon.cpp | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/httpcommon.cpp b/indra/llcorehttp/httpcommon.cpp
index c201400423..d923dfa5d6 100755
--- a/indra/llcorehttp/httpcommon.cpp
+++ b/indra/llcorehttp/httpcommon.cpp
@@ -131,18 +131,18 @@ std::string HttpStatus::toString() const
 	{
 		return std::string("");
 	}
-	switch (this->mDetails->mType)
+	switch (getType())
 	{
 	case EXT_CURL_EASY:
-		return std::string(curl_easy_strerror(CURLcode(this->mDetails->mStatus)));
+		return std::string(curl_easy_strerror(CURLcode(getStatus())));
 
 	case EXT_CURL_MULTI:
-		return std::string(curl_multi_strerror(CURLMcode(this->mDetails->mStatus)));
+		return std::string(curl_multi_strerror(CURLMcode(getStatus())));
 
 	case LLCORE:
-		if (this->mDetails->mStatus >= 0 && this->mDetails->mStatus < llcore_errors_count)
+		if (getStatus() >= 0 && getStatus() < llcore_errors_count)
 		{
-			return std::string(llcore_errors[this->mDetails->mStatus]);
+			return std::string(llcore_errors[getStatus()]);
 		}
 		break;
 
@@ -154,7 +154,7 @@ std::string HttpStatus::toString() const
 			while (true)
 			{
 				int at((bottom + top) / 2);
-				if (this->mDetails->mType == http_errors[at].mCode)
+				if (getType() == http_errors[at].mCode)
 				{
 					return std::string(http_errors[at].mText);
 				}
@@ -162,7 +162,7 @@ std::string HttpStatus::toString() const
 				{
 					break;
 				}
-				else if (this->mDetails->mType < http_errors[at].mCode)
+				else if (getType() < http_errors[at].mCode)
 				{
 					top = at;
 				}
@@ -182,9 +182,9 @@ std::string HttpStatus::toTerseString() const
 {
 	std::ostringstream result;
 
-	unsigned int error_value((unsigned short)(this->mDetails->mStatus));
+	unsigned int error_value((unsigned short)getStatus());
 	
-	switch (this->mDetails->mType)
+	switch (getType())
 	{
 	case EXT_CURL_EASY:
 		result << "Easy_";
@@ -202,7 +202,7 @@ std::string HttpStatus::toTerseString() const
 		if (isHttpStatus())
 		{
 			result << "Http_";
-			error_value = this->mDetails->mType;
+			error_value = getType();
 		}
 		else
 		{
@@ -244,7 +244,7 @@ bool HttpStatus::isRetryable() const
 	// Disable the '*this == inv_status' test and look for 'Core_9'
 	// failures in log files.
 
-	return ((isHttpStatus() && this->mDetails->mType >= 499 && this->mDetails->mType <= 599) ||	// Include special 499 in retryables
+	return ((isHttpStatus() && getType() >= 499 && getType() <= 599) ||	// Include special 499 in retryables
 			*this == cant_connect ||	// Connection reset/endpoint problems
 			*this == cant_res_proxy ||	// DNS problems
 			*this == cant_res_host ||	// DNS problems
-- 
cgit v1.3


From 379c49fc898961b52f98855c926e958df14e98c3 Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Mon, 23 Mar 2015 13:50:07 -0700
Subject: Scratch the unique_ptr for the moment.

---
 indra/llcorehttp/httpcommon.h | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/httpcommon.h b/indra/llcorehttp/httpcommon.h
index 0244755272..2aded492ea 100755
--- a/indra/llcorehttp/httpcommon.h
+++ b/indra/llcorehttp/httpcommon.h
@@ -188,7 +188,6 @@
 ///
 
 #include "linden_common.h"		// Modifies curl/curl.h interfaces
-
 #include <string>
 
 namespace LLCore
@@ -292,24 +291,29 @@ struct HttpStatus
 	
 	HttpStatus()
 		{
-			mDetails = std::unique_ptr<Details>(new Details(LLCORE, HE_SUCCESS));
-		}
+			mDetails = new Details(LLCORE, HE_SUCCESS);
+	}
 
 	HttpStatus(type_enum_t type, short status)
 		{
-			mDetails = std::unique_ptr<Details>(new Details(type, status));
+			mDetails = new Details(type, status);
 		}
 	
 	HttpStatus(int http_status)
 		{
-			mDetails = std::unique_ptr<Details>(new Details(http_status, 
-				(http_status >= 200 && http_status <= 299) ? HE_SUCCESS : HE_REPLY_ERROR));
+			mDetails = new Details(http_status, 
+				(http_status >= 200 && http_status <= 299) ? HE_SUCCESS : HE_REPLY_ERROR);
 			llassert(http_status >= 100 && http_status <= 999);
 		}
 	
 	HttpStatus(const HttpStatus & rhs)
 		{
-			mDetails = std::unique_ptr<Details>(new Details(*rhs.mDetails));
+			mDetails = new Details(*rhs.mDetails);
+		}
+
+	~HttpStatus()
+		{
+			delete mDetails;
 		}
 
 	HttpStatus & operator=(const HttpStatus & rhs)
@@ -468,7 +472,8 @@ private:
 		void *		mErrorData;
 	};
 
-	std::unique_ptr<Details>	mDetails;
+	//boost::unique_ptr<Details>	mDetails;
+	Details * mDetails;
 
 }; // end struct HttpStatus
 
-- 
cgit v1.3


From 90ae8b84c6bf515486ec94038abc598520e2320f Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Mon, 23 Mar 2015 14:22:07 -0700
Subject: Fix headers for gcc build

---
 indra/llcorehttp/httpcommon.h  | 1 +
 indra/llcorehttp/httpheaders.h | 2 +-
 indra/llcorehttp/httpoptions.h | 1 -
 3 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/httpcommon.h b/indra/llcorehttp/httpcommon.h
index 2aded492ea..e806201798 100755
--- a/indra/llcorehttp/httpcommon.h
+++ b/indra/llcorehttp/httpcommon.h
@@ -188,6 +188,7 @@
 ///
 
 #include "linden_common.h"		// Modifies curl/curl.h interfaces
+#include "boost/intrusive_ptr.hpp"
 #include <string>
 
 namespace LLCore
diff --git a/indra/llcorehttp/httpheaders.h b/indra/llcorehttp/httpheaders.h
index 41832c4931..940f92183c 100755
--- a/indra/llcorehttp/httpheaders.h
+++ b/indra/llcorehttp/httpheaders.h
@@ -28,8 +28,8 @@
 #define	_LLCORE_HTTP_HEADERS_H_
 
 
+#include "httpcommon.h"
 #include <string>
-
 #include "_refcounted.h"
 
 
diff --git a/indra/llcorehttp/httpoptions.h b/indra/llcorehttp/httpoptions.h
index d6d892213d..3b9ad9598b 100755
--- a/indra/llcorehttp/httpoptions.h
+++ b/indra/llcorehttp/httpoptions.h
@@ -29,7 +29,6 @@
 
 
 #include "httpcommon.h"
-
 #include "_refcounted.h"
 
 
-- 
cgit v1.3


From d46fe1a1bb0c375ebcfe3c1fe9701e37135acd65 Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Mon, 23 Mar 2015 14:48:34 -0700
Subject: Microsoft is not nearly picky enough. Headder issues caught by gcc MS
 likes fine.

---
 indra/llcorehttp/httpcommon.h    |  1 +
 indra/llcorehttp/httprequest.h   |  2 +-
 indra/llcorehttp/httpresponse.h  |  2 +-
 indra/llmessage/llhttpclient.cpp | 45 ----------------------------------------
 4 files changed, 3 insertions(+), 47 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/httpcommon.h b/indra/llcorehttp/httpcommon.h
index e806201798..e673d7b589 100755
--- a/indra/llcorehttp/httpcommon.h
+++ b/indra/llcorehttp/httpcommon.h
@@ -189,6 +189,7 @@
 
 #include "linden_common.h"		// Modifies curl/curl.h interfaces
 #include "boost/intrusive_ptr.hpp"
+#include "boost/shared_ptr.hpp"
 #include <string>
 
 namespace LLCore
diff --git a/indra/llcorehttp/httprequest.h b/indra/llcorehttp/httprequest.h
index c90e056d62..4cacb3a20b 100755
--- a/indra/llcorehttp/httprequest.h
+++ b/indra/llcorehttp/httprequest.h
@@ -97,7 +97,7 @@ public:
 	typedef unsigned int policy_t;
 	typedef unsigned int priority_t;
 	
-	typedef std::shared_ptr<HttpRequest> ptr_t;
+	typedef boost::shared_ptr<HttpRequest> ptr_t;
 public:
 	/// @name PolicyMethods
 	/// @{
diff --git a/indra/llcorehttp/httpresponse.h b/indra/llcorehttp/httpresponse.h
index c6b470ee3f..39b582ff85 100755
--- a/indra/llcorehttp/httpresponse.h
+++ b/indra/llcorehttp/httpresponse.h
@@ -72,7 +72,7 @@ public:
 	/// Statistics for the HTTP 
 	struct TransferStats
 	{
-		typedef std::shared_ptr<TransferStats> ptr_t;
+		typedef boost::shared_ptr<TransferStats> ptr_t;
 
 		TransferStats() : mSizeDownload(0.0), mTotalTime(0.0), mSpeedDownload(0.0) {}
 		F64 mSizeDownload;
diff --git a/indra/llmessage/llhttpclient.cpp b/indra/llmessage/llhttpclient.cpp
index 27c94b1182..b4a76cb808 100755
--- a/indra/llmessage/llhttpclient.cpp
+++ b/indra/llmessage/llhttpclient.cpp
@@ -218,51 +218,6 @@ void LLHTTPClient::setCertVerifyCallback(LLURLRequest::SSLCertVerifyCallback cal
 	LLHTTPClient::mCertVerifyCallback = callback;
 }
 
-#if 0
-typedef std::shared_ptr<LLCore::HttpRequest> HttpRequestPtr_t;
-typedef std::unique_ptr<LLCore::HttpOptions> HttpOptionsPtr_t;
-typedef std::unique_ptr<Injector> InjectorPtr_t;
-
-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
-	)
-{
-	HttpRequestPtr_t httpReq = HttpRequestPtr_t(new LLCore::HttpRequest());
-
-	HttpOptionsPtr_t httpOpts = HttpOptionsPtr_t(new LLCore::HttpOptions());
-
-	httpOpts->setFollowRedirects(follow_redirects);
-	httpOpts->setRetries(12);
-	httpOpts->setUseRetryAfter(true);
-	// for the moment lets just truncate.  60 seconds vs 60.5 seconds 
-	httpOpts->setTransferTimeout((unsigned int)timeout); 
-
-	switch (method)
-	{
-	case HTTP_GET:
-		httpReq->requestGet(0, 0, url, httpOpts.get(), headers, handler);
-		break;
-	case HTTP_HEAD:
-		httpReq->requestHead(0, 0, url, httpOpts.get(), headers, handler);
-		break;
-	case HTTP_PUT:
-		httpReq->requestPut(0, 0, url, );
-		break;
-	case HTTP_POST:
-		httpReq->requestPost(0, 0, url, null, httpOpts.get(), headers, handler);
-		break;
-	}
-
-
-}
-#endif 
-
 static void request(
 	const std::string& url,
 	EHTTPMethod method,
-- 
cgit v1.3


From d9e886809685cc207a52d0429d1badf6d537e5d7 Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Mon, 23 Mar 2015 15:41:40 -0700
Subject: Fix the tests to not directly access HttpsStatus' internals.

---
 indra/llcorehttp/tests/test_httpstatus.hpp | 90 +++++++++++-------------------
 1 file changed, 33 insertions(+), 57 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/tests/test_httpstatus.hpp b/indra/llcorehttp/tests/test_httpstatus.hpp
index 0b379836c9..5f8ed14c51 100755
--- a/indra/llcorehttp/tests/test_httpstatus.hpp
+++ b/indra/llcorehttp/tests/test_httpstatus.hpp
@@ -55,32 +55,28 @@ void HttpStatusTestObjectType::test<1>()
 	
 	// auto allocation fine for this
 	HttpStatus status;
-	status.mType = HttpStatus::EXT_CURL_EASY;
-	status.mStatus = 0;
+
+	status = HttpStatus(HttpStatus::EXT_CURL_EASY, 0);
 	
 	ensure(bool(status));
 	ensure(false == !(status));
 
-	status.mType = HttpStatus::EXT_CURL_MULTI;
-	status.mStatus = 0;
+	status = HttpStatus(HttpStatus::EXT_CURL_MULTI, 0);
 
 	ensure(bool(status));
 	ensure(false == !(status));
-	
-	status.mType = HttpStatus::LLCORE;
-	status.mStatus = HE_SUCCESS;
+
+	status = HttpStatus(HttpStatus::LLCORE, HE_SUCCESS);
 	
 	ensure(bool(status));
 	ensure(false == !(status));
 
-	status.mType = HttpStatus::EXT_CURL_MULTI;
-	status.mStatus = -1;
+	status = HttpStatus(HttpStatus::EXT_CURL_MULTI, -1);
 
 	ensure(false == bool(status));
 	ensure(!(status));
 
-	status.mType = HttpStatus::EXT_CURL_EASY;
-	status.mStatus = CURLE_BAD_DOWNLOAD_RESUME;
+	status = HttpStatus(HttpStatus::EXT_CURL_EASY, CURLE_BAD_DOWNLOAD_RESUME);
 
 	ensure(false == bool(status));
 	ensure(!(status));
@@ -105,27 +101,22 @@ void HttpStatusTestObjectType::test<3>()
 {
 	set_test_name("HttpStatus valid status string conversion");
 	
-	HttpStatus status;
-	status.mType = HttpStatus::EXT_CURL_EASY;
-	status.mStatus = 0;
+	HttpStatus status = HttpStatus(HttpStatus::EXT_CURL_EASY, 0);
 	std::string msg = status.toString();
 	// std::cout << "Result:  " << msg << std::endl;
 	ensure(msg.empty());
-	
-	status.mType = HttpStatus::EXT_CURL_EASY;
-	status.mStatus = CURLE_BAD_FUNCTION_ARGUMENT;
+
+	status = HttpStatus(HttpStatus::EXT_CURL_EASY, CURLE_BAD_FUNCTION_ARGUMENT);
 	msg = status.toString();
 	// std::cout << "Result:  " << msg << std::endl;
 	ensure(! msg.empty());
 
-	status.mType = HttpStatus::EXT_CURL_MULTI;
-	status.mStatus = CURLM_OUT_OF_MEMORY;
+	status = HttpStatus(HttpStatus::EXT_CURL_MULTI, CURLM_OUT_OF_MEMORY);
 	msg = status.toString();
 	// std::cout << "Result:  " << msg << std::endl;
 	ensure(! msg.empty());
 
-	status.mType = HttpStatus::LLCORE;
-	status.mStatus = HE_SHUTTING_DOWN;
+	status = HttpStatus(HttpStatus::LLCORE, HE_SHUTTING_DOWN);
 	msg = status.toString();
 	// std::cout << "Result:  " << msg << std::endl;
 	ensure(! msg.empty());
@@ -137,21 +128,17 @@ void HttpStatusTestObjectType::test<4>()
 {
 	set_test_name("HttpStatus invalid status string conversion");
 	
-	HttpStatus status;
-	status.mType = HttpStatus::EXT_CURL_EASY;
-	status.mStatus = 32726;
+	HttpStatus status = HttpStatus(HttpStatus::EXT_CURL_EASY, 32726);
 	std::string msg = status.toString();
 	// std::cout << "Result:  " << msg << std::endl;
 	ensure(! msg.empty());
-	
-	status.mType = HttpStatus::EXT_CURL_MULTI;
-	status.mStatus = -470;
+
+	status = HttpStatus(HttpStatus::EXT_CURL_MULTI, -470);
 	msg = status.toString();
 	// std::cout << "Result:  " << msg << std::endl;
 	ensure(! msg.empty());
 
-	status.mType = HttpStatus::LLCORE;
-	status.mStatus = 923;
+	status = HttpStatus(HttpStatus::LLCORE, 923);
 	msg = status.toString();
 	// std::cout << "Result:  " << msg << std::endl;
 	ensure(! msg.empty());
@@ -170,10 +157,9 @@ void HttpStatusTestObjectType::test<5>()
 	HttpStatus status2(HttpStatus::EXT_CURL_EASY, HE_SUCCESS);
 	ensure(status1 != status2);
 
-	status1.mType = HttpStatus::LLCORE;
-	status1.mStatus = HE_REPLY_ERROR;
-	status2.mType = HttpStatus::LLCORE;
-	status2.mStatus= HE_SHUTTING_DOWN;
+	status1 = HttpStatus(HttpStatus::LLCORE, HE_REPLY_ERROR);
+	status1 = HttpStatus(HttpStatus::LLCORE, HE_SHUTTING_DOWN);
+
 	ensure(status1 != status2);
 }
 
@@ -183,44 +169,38 @@ void HttpStatusTestObjectType::test<6>()
 	set_test_name("HttpStatus basic HTTP status encoding");
 	
 	HttpStatus status;
-	status.mType = 200;
-	status.mStatus = HE_SUCCESS;
+
+	status = HttpStatus(200, HE_SUCCESS);
 	std::string msg = status.toString();
 	ensure(msg.empty());
 	ensure(bool(status));
 
 	// Normally a success but application says error
-	status.mStatus = HE_REPLY_ERROR;
+	status = HttpStatus(200, HE_REPLY_ERROR);
 	msg = status.toString();
 	ensure(! msg.empty());
 	ensure(! bool(status));
 	ensure(status.toULong() > 1UL);				// Biggish number, not a bool-to-ulong
 
 	// Same statuses with distinct success/fail are distinct
-	status.mType = 200;
-	status.mStatus = HE_SUCCESS;
+	status = HttpStatus(200, HE_SUCCESS);
 	HttpStatus status2(200, HE_REPLY_ERROR);
 	ensure(status != status2);
 
 	// Normally an error but application says okay
-	status.mType = 406;
-	status.mStatus = HE_SUCCESS;
+	status = HttpStatus(406, HE_SUCCESS);
 	msg = status.toString();
 	ensure(msg.empty());
 	ensure(bool(status));
 
 	// Different statuses but both successful are distinct
-	status.mType = 200;
-	status.mStatus = HE_SUCCESS;
-	status2.mType = 201;
-	status2.mStatus = HE_SUCCESS;
+	status = HttpStatus(200, HE_SUCCESS);
+	status2 = HttpStatus(201, HE_SUCCESS);
 	ensure(status != status2);
 
 	// Different statuses but both failed are distinct
-	status.mType = 200;
-	status.mStatus = HE_REPLY_ERROR;
-	status2.mType = 201;
-	status2.mStatus = HE_REPLY_ERROR;
+	status = HttpStatus(200, HE_REPLY_ERROR);
+	status2 = HttpStatus(201, HE_REPLY_ERROR);
 	ensure(status != status2);
 }
 
@@ -234,27 +214,23 @@ void HttpStatusTestObjectType::test<7>()
 	ensure(! msg.empty());				// Should be something
 	ensure(msg == "Continue");
 
-	status.mStatus = HE_SUCCESS;
+	status = HttpStatus(200, HE_SUCCESS);
 	msg = status.toString();
 	ensure(msg.empty());				// Success is empty
 
-	status.mType = 199;
-	status.mStatus = HE_REPLY_ERROR;
+	status = HttpStatus(199, HE_REPLY_ERROR);
 	msg = status.toString();
 	ensure(msg == "Unknown error");
 
-	status.mType = 505;					// Last defined string
-	status.mStatus = HE_REPLY_ERROR;
+	status = HttpStatus(505, HE_REPLY_ERROR);
 	msg = status.toString();
 	ensure(msg == "HTTP Version not supported");
 
-	status.mType = 506;					// One beyond
-	status.mStatus = HE_REPLY_ERROR;
+	status = HttpStatus(506, HE_REPLY_ERROR);
 	msg = status.toString();
 	ensure(msg == "Unknown error");
 
-	status.mType = 999;					// Last HTTP status
-	status.mStatus = HE_REPLY_ERROR;
+	status = HttpStatus(999, HE_REPLY_ERROR);
 	msg = status.toString();
 	ensure(msg == "Unknown error");
 }
-- 
cgit v1.3


From e140118fc41b79e403b299cabe1653af1971e87a Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Wed, 25 Mar 2015 11:31:11 -0700
Subject: Replace appearance responder with new LLCore Appearance Handler. Prep
 for some slight cleanup of the code. Add AP_AVATAR Policy

---
 indra/llcorehttp/httpcommon.cpp       |    4 +
 indra/llcorehttp/httpcommon.h         |   13 +-
 indra/llmessage/llhttpsdhandler.cpp   |    4 +-
 indra/newview/llappcorehttp.cpp       |    5 +
 indra/newview/llappcorehttp.h         |   13 +-
 indra/newview/llappearancemgr.cpp     | 8282 +++++++++++++++++----------------
 indra/newview/llappearancemgr.h       |   20 +-
 indra/newview/llmaterialmgr.cpp       |    2 +-
 indra/newview/llxmlrpctransaction.cpp |    8 -
 9 files changed, 4200 insertions(+), 4151 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/httpcommon.cpp b/indra/llcorehttp/httpcommon.cpp
index d923dfa5d6..99238ea920 100755
--- a/indra/llcorehttp/httpcommon.cpp
+++ b/indra/llcorehttp/httpcommon.cpp
@@ -149,6 +149,10 @@ std::string HttpStatus::toString() const
 	default:
 		if (isHttpStatus())
 		{
+			// special handling for status 499 "Linden Catchall"
+			if ((getType() == 499) && (!getMessage().empty()))
+				return getMessage();
+
 			// Binary search for the error code and string
 			int bottom(0), top(http_errors_count);
 			while (true)
diff --git a/indra/llcorehttp/httpcommon.h b/indra/llcorehttp/httpcommon.h
index e673d7b589..64075f5f20 100755
--- a/indra/llcorehttp/httpcommon.h
+++ b/indra/llcorehttp/httpcommon.h
@@ -286,6 +286,8 @@ enum HttpError
 /// 5.  Construct an HTTP 301 status code to be treated as success:
 ///				HttpStatus(301, HE_SUCCESS);
 ///
+/// 6.	Construct a failed status of HTTP Status 499 with a custom error message
+///				HttpStatus(499, "Failed LLSD Response");
 
 struct HttpStatus
 {
@@ -307,6 +309,14 @@ struct HttpStatus
 				(http_status >= 200 && http_status <= 299) ? HE_SUCCESS : HE_REPLY_ERROR);
 			llassert(http_status >= 100 && http_status <= 999);
 		}
+
+	HttpStatus(int http_status, const std::string &message)
+		{
+			mDetails = new Details(http_status,
+				(http_status >= 200 && http_status <= 299) ? HE_SUCCESS : HE_REPLY_ERROR);
+			llassert(http_status >= 100 && http_status <= 999);
+			mDetails->mMessage = message;
+		}
 	
 	HttpStatus(const HttpStatus & rhs)
 		{
@@ -420,9 +430,6 @@ struct HttpStatus
 		return mDetails->mType;
 	}
 
-	// TODO: There must be a better way to do this.  Don't want to set these 
-	// values here since they increase the size of a structure that is already 
-	// being passed on the stack.  Consider my options
 	/// Returns an optional error message if one has been set.
 	///
 	std::string getMessage() const
diff --git a/indra/llmessage/llhttpsdhandler.cpp b/indra/llmessage/llhttpsdhandler.cpp
index aa9801cebc..18daf443ee 100644
--- a/indra/llmessage/llhttpsdhandler.cpp
+++ b/indra/llmessage/llhttpsdhandler.cpp
@@ -76,7 +76,9 @@ void LLHttpSDHandler::onCompleted(LLCore::HttpHandle handle, LLCore::HttpRespons
 		this->onSuccess(response, resplsd);
 	}
 
-	// The handler must destroy itself when it is done.
+	// The handler must destroy itself when it is done. 
+	// *TODO: I'm not fond of this pattern. A class shooting itself in the head 
+	// outside of a smart pointer always makes me nervous.
 	delete this;
 }
 
diff --git a/indra/newview/llappcorehttp.cpp b/indra/newview/llappcorehttp.cpp
index 420d37369f..8da78a45a6 100755
--- a/indra/newview/llappcorehttp.cpp
+++ b/indra/newview/llappcorehttp.cpp
@@ -102,6 +102,11 @@ static const struct
 		2,		1,		8,		0,		false,
 		"RenderMaterials",
 		"material manager requests"
+	},
+	{ // AP_AVATAR
+		2,		1,		32,		0,		true,
+		"Avatar",
+		"Avatar requests"
 	}
 };
 
diff --git a/indra/newview/llappcorehttp.h b/indra/newview/llappcorehttp.h
index b636c3b43c..95b56100a6 100755
--- a/indra/newview/llappcorehttp.h
+++ b/indra/newview/llappcorehttp.h
@@ -175,7 +175,18 @@ public:
 		/// Request rate:    low
 		/// Pipelined:       no
 		AP_MATERIALS,
-		
+
+		/// Appearance resource requests and puts.  
+		///
+		/// Destination:     simhost:12043
+		/// Protocol:        https:
+		/// Transfer size:   KB
+		/// Long poll:       no
+		/// Concurrency:     mid
+		/// Request rate:    low
+		/// Pipelined:       yes
+		AP_AVATAR,
+
 		AP_COUNT						// Must be last
 	};
 	
diff --git a/indra/newview/llappearancemgr.cpp b/indra/newview/llappearancemgr.cpp
index 9e8479eeef..077e944925 100755
--- a/indra/newview/llappearancemgr.cpp
+++ b/indra/newview/llappearancemgr.cpp
@@ -1,4138 +1,4150 @@
-/** 
- * @file llappearancemgr.cpp
- * @brief Manager for initiating appearance changes on the viewer
- *
- * $LicenseInfo:firstyear=2004&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 "llviewerprecompiledheaders.h"
-
-#include <boost/lexical_cast.hpp>
-#include "llaccordionctrltab.h"
-#include "llagent.h"
-#include "llagentcamera.h"
-#include "llagentwearables.h"
-#include "llappearancemgr.h"
-#include "llattachmentsmgr.h"
-#include "llcommandhandler.h"
-#include "lleventtimer.h"
-#include "llfloatersidepanelcontainer.h"
-#include "llgesturemgr.h"
-#include "llinventorybridge.h"
-#include "llinventoryfunctions.h"
-#include "llinventoryobserver.h"
-#include "llnotificationsutil.h"
-#include "lloutfitobserver.h"
-#include "lloutfitslist.h"
-#include "llselectmgr.h"
-#include "llsidepanelappearance.h"
-#include "llviewerobjectlist.h"
-#include "llvoavatar.h"
-#include "llvoavatarself.h"
-#include "llviewerregion.h"
-#include "llwearablelist.h"
-#include "llsdutil.h"
-#include "llsdserialize.h"
-#include "llhttpretrypolicy.h"
-#include "llaisapi.h"
-
-#if LL_MSVC
-// disable boost::lexical_cast warning
-#pragma warning (disable:4702)
-#endif
-
-std::string self_av_string()
-{
-	// On logout gAgentAvatarp can already be invalid
-	return isAgentAvatarValid() ? gAgentAvatarp->avString() : "";
-}
-
-// RAII thingy to guarantee that a variable gets reset when the Setter
-// goes out of scope.  More general utility would be handy - TODO:
-// check boost.
-class BoolSetter
-{
-public:
-	BoolSetter(bool& var):
-		mVar(var)
-	{
-		mVar = true;
-	}
-	~BoolSetter()
-	{
-		mVar = false; 
-	}
-private:
-	bool& mVar;
-};
-
-char ORDER_NUMBER_SEPARATOR('@');
-
-class LLOutfitUnLockTimer: public LLEventTimer
-{
-public:
-	LLOutfitUnLockTimer(F32 period) : LLEventTimer(period)
-	{
-		// restart timer on BOF changed event
-		LLOutfitObserver::instance().addBOFChangedCallback(boost::bind(
-				&LLOutfitUnLockTimer::reset, this));
-		stop();
-	}
-
-	/*virtual*/
-	BOOL tick()
-	{
-		if(mEventTimer.hasExpired())
-		{
-			LLAppearanceMgr::instance().setOutfitLocked(false);
-		}
-		return FALSE;
-	}
-	void stop() { mEventTimer.stop(); }
-	void start() { mEventTimer.start(); }
-	void reset() { mEventTimer.reset(); }
-	BOOL getStarted() { return mEventTimer.getStarted(); }
-
-	LLTimer&  getEventTimer() { return mEventTimer;}
-};
-
-// support for secondlife:///app/appearance SLapps
-class LLAppearanceHandler : public LLCommandHandler
-{
-public:
-	// requests will be throttled from a non-trusted browser
-	LLAppearanceHandler() : LLCommandHandler("appearance", UNTRUSTED_THROTTLE) {}
-
-	bool handle(const LLSD& params, const LLSD& query_map, LLMediaCtrl* web)
-	{
-		// support secondlife:///app/appearance/show, but for now we just
-		// make all secondlife:///app/appearance SLapps behave this way
-		if (!LLUI::sSettingGroups["config"]->getBOOL("EnableAppearance"))
-		{
-			LLNotificationsUtil::add("NoAppearance", LLSD(), LLSD(), std::string("SwitchToStandardSkinAndQuit"));
-			return true;
-		}
-
-		LLFloaterSidePanelContainer::showPanel("appearance", LLSD());
-		return true;
-	}
-};
-
-LLAppearanceHandler gAppearanceHandler;
-
-
-LLUUID findDescendentCategoryIDByName(const LLUUID& parent_id, const std::string& name)
-{
-	LLInventoryModel::cat_array_t cat_array;
-	LLInventoryModel::item_array_t item_array;
-	LLNameCategoryCollector has_name(name);
-	gInventory.collectDescendentsIf(parent_id,
-									cat_array,
-									item_array,
-									LLInventoryModel::EXCLUDE_TRASH,
-									has_name);
-	if (0 == cat_array.size())
-		return LLUUID();
-	else
-	{
-		LLViewerInventoryCategory *cat = cat_array.at(0);
-		if (cat)
-			return cat->getUUID();
-		else
-		{
-			LL_WARNS() << "null cat" << LL_ENDL;
-			return LLUUID();
-		}
-	}
-}
-
-// We want this to be much lower (e.g. 15.0 is usually fine), bumping
-// up for now until we can diagnose some cases of very slow response
-// to requests.
-const F32 DEFAULT_RETRY_AFTER_INTERVAL = 300.0;
-
-// Given the current back-end problems, retrying is causing too many
-// duplicate items. Bump this back to 2 once they are resolved (or can
-// leave at 0 if the operations become actually reliable).
-const S32 DEFAULT_MAX_RETRIES = 0;
-
-class LLCallAfterInventoryBatchMgr: public LLEventTimer 
-{
-public:
-	LLCallAfterInventoryBatchMgr(const LLUUID& dst_cat_id,
-								 const std::string& phase_name,
-								 nullary_func_t on_completion_func,
-								 nullary_func_t on_failure_func = no_op,
-								 F32 retry_after = DEFAULT_RETRY_AFTER_INTERVAL,
-								 S32 max_retries = DEFAULT_MAX_RETRIES
-		):
-		mDstCatID(dst_cat_id),
-		mTrackingPhase(phase_name),
-		mOnCompletionFunc(on_completion_func),
-		mOnFailureFunc(on_failure_func),
-		mRetryAfter(retry_after),
-		mMaxRetries(max_retries),
-		mPendingRequests(0),
-		mFailCount(0),
-		mCompletionOrFailureCalled(false),
-		mRetryCount(0),
-		LLEventTimer(5.0)
-	{
-		if (!mTrackingPhase.empty())
-		{
-			selfStartPhase(mTrackingPhase);
-		}
-	}
-
-	void addItems(LLInventoryModel::item_array_t& src_items)
-	{
-		for (LLInventoryModel::item_array_t::const_iterator it = src_items.begin();
-			 it != src_items.end();
-			 ++it)
-		{
-			LLViewerInventoryItem* item = *it;
-			llassert(item);
-			addItem(item->getUUID());
-		}
-	}
-
-	// Request or re-request operation for specified item.
-	void addItem(const LLUUID& item_id)
-	{
-		LL_DEBUGS("Avatar") << "item_id " << item_id << LL_ENDL;
-		if (!requestOperation(item_id))
-		{
-			LL_DEBUGS("Avatar") << "item_id " << item_id << " requestOperation false, skipping" << LL_ENDL;
-			return;
-		}
-
-		mPendingRequests++;
-		// On a re-request, this will reset the timer.
-		mWaitTimes[item_id] = LLTimer();
-		if (mRetryCounts.find(item_id) == mRetryCounts.end())
-		{
-			mRetryCounts[item_id] = 0;
-		}
-		else
-		{
-			mRetryCounts[item_id]++;
-		}
-	}
-
-	virtual bool requestOperation(const LLUUID& item_id) = 0;
-
-	void onOp(const LLUUID& src_id, const LLUUID& dst_id, LLTimer timestamp)
-	{
-		if (ll_frand() < gSavedSettings.getF32("InventoryDebugSimulateLateOpRate"))
-		{
-			LL_WARNS() << "Simulating late operation by punting handling to later" << LL_ENDL;
-			doAfterInterval(boost::bind(&LLCallAfterInventoryBatchMgr::onOp,this,src_id,dst_id,timestamp),
-							mRetryAfter);
-			return;
-		}
-		mPendingRequests--;
-		F32 elapsed = timestamp.getElapsedTimeF32();
-		LL_DEBUGS("Avatar") << "op done, src_id " << src_id << " dst_id " << dst_id << " after " << elapsed << " seconds" << LL_ENDL;
-		if (mWaitTimes.find(src_id) == mWaitTimes.end())
-		{
-			// No longer waiting for this item - either serviced
-			// already or gave up after too many retries.
-			LL_WARNS() << "duplicate or late operation, src_id " << src_id << "dst_id " << dst_id
-					<< " elapsed " << elapsed << " after end " << (S32) mCompletionOrFailureCalled << LL_ENDL;
-		}
-		mTimeStats.push(elapsed);
-		mWaitTimes.erase(src_id);
-		if (mWaitTimes.empty() && !mCompletionOrFailureCalled)
-		{
-			onCompletionOrFailure();
-		}
-	}
-
-	void onCompletionOrFailure()
-	{
-		assert (!mCompletionOrFailureCalled);
-		mCompletionOrFailureCalled = true;
-		
-		// Will never call onCompletion() if any item has been flagged as
-		// a failure - otherwise could wind up with corrupted
-		// outfit, involuntary nudity, etc.
-		reportStats();
-		if (!mTrackingPhase.empty())
-		{
-			selfStopPhase(mTrackingPhase);
-		}
-		if (!mFailCount)
-		{
-			onCompletion();
-		}
-		else
-		{
-			onFailure();
-		}
-	}
-
-	void onFailure()
-	{
-		LL_INFOS() << "failed" << LL_ENDL;
-		mOnFailureFunc();
-	}
-
-	void onCompletion()
-	{
-		LL_INFOS() << "done" << LL_ENDL;
-		mOnCompletionFunc();
-	}
-	
-	// virtual
-	// Will be deleted after returning true - only safe to do this if all callbacks have fired.
-	BOOL tick()
-	{
-		// mPendingRequests will be zero if all requests have been
-		// responded to.  mWaitTimes.empty() will be true if we have
-		// received at least one reply for each UUID.  If requests
-		// have been dropped and retried, these will not necessarily
-		// be the same.  Only safe to return true if all requests have
-		// been serviced, since it will result in this object being
-		// deleted.
-		bool all_done = (mPendingRequests==0);
-
-		if (!mWaitTimes.empty())
-		{
-			LL_WARNS() << "still waiting on " << mWaitTimes.size() << " items" << LL_ENDL;
-			for (std::map<LLUUID,LLTimer>::iterator it = mWaitTimes.begin();
-				 it != mWaitTimes.end();)
-			{
-				// Use a copy of iterator because it may be erased/invalidated.
-				std::map<LLUUID,LLTimer>::iterator curr_it = it;
-				++it;
-				
-				F32 time_waited = curr_it->second.getElapsedTimeF32();
-				S32 retries = mRetryCounts[curr_it->first];
-				if (time_waited > mRetryAfter)
-				{
-					if (retries < mMaxRetries)
-					{
-						LL_DEBUGS("Avatar") << "Waited " << time_waited <<
-							" for " << curr_it->first << ", retrying" << LL_ENDL;
-						mRetryCount++;
-						addItem(curr_it->first);
-					}
-					else
-					{
-						LL_WARNS() << "Giving up on " << curr_it->first << " after too many retries" << LL_ENDL;
-						mWaitTimes.erase(curr_it);
-						mFailCount++;
-					}
-				}
-				if (mWaitTimes.empty())
-				{
-					onCompletionOrFailure();
-				}
-
-			}
-		}
-		return all_done;
-	}
-
-	void reportStats()
-	{
-		LL_DEBUGS("Avatar") << "Phase: " << mTrackingPhase << LL_ENDL;
-		LL_DEBUGS("Avatar") << "mFailCount: " << mFailCount << LL_ENDL;
-		LL_DEBUGS("Avatar") << "mRetryCount: " << mRetryCount << LL_ENDL;
-		LL_DEBUGS("Avatar") << "Times: n " << mTimeStats.getCount() << " min " << mTimeStats.getMinValue() << " max " << mTimeStats.getMaxValue() << LL_ENDL;
-		LL_DEBUGS("Avatar") << "Mean " << mTimeStats.getMean() << " stddev " << mTimeStats.getStdDev() << LL_ENDL;
-	}
-	
-	virtual ~LLCallAfterInventoryBatchMgr()
-	{
-		LL_DEBUGS("Avatar") << "deleting" << LL_ENDL;
-	}
-
-protected:
-	std::string mTrackingPhase;
-	std::map<LLUUID,LLTimer> mWaitTimes;
-	std::map<LLUUID,S32> mRetryCounts;
-	LLUUID mDstCatID;
-	nullary_func_t mOnCompletionFunc;
-	nullary_func_t mOnFailureFunc;
-	F32 mRetryAfter;
-	S32 mMaxRetries;
-	S32 mPendingRequests;
-	S32 mFailCount;
-	S32 mRetryCount;
-	bool mCompletionOrFailureCalled;
-	LLViewerStats::StatsAccumulator mTimeStats;
-};
-
-class LLCallAfterInventoryCopyMgr: public LLCallAfterInventoryBatchMgr
-{
-public:
-	LLCallAfterInventoryCopyMgr(LLInventoryModel::item_array_t& src_items,
-								const LLUUID& dst_cat_id,
-								const std::string& phase_name,
-								nullary_func_t on_completion_func,
-								nullary_func_t on_failure_func = no_op,
-								 F32 retry_after = DEFAULT_RETRY_AFTER_INTERVAL,
-								 S32 max_retries = DEFAULT_MAX_RETRIES
-		):
-		LLCallAfterInventoryBatchMgr(dst_cat_id, phase_name, on_completion_func, on_failure_func, retry_after, max_retries)
-	{
-		addItems(src_items);
-		sInstanceCount++;
-	}
-
-	~LLCallAfterInventoryCopyMgr()
-	{
-		sInstanceCount--;
-	}
-	
-	virtual bool requestOperation(const LLUUID& item_id)
-	{
-		LLViewerInventoryItem *item = gInventory.getItem(item_id);
-		llassert(item);
-		LL_DEBUGS("Avatar") << "copying item " << item_id << LL_ENDL;
-		if (ll_frand() < gSavedSettings.getF32("InventoryDebugSimulateOpFailureRate"))
-		{
-			LL_DEBUGS("Avatar") << "simulating failure by not sending request for item " << item_id << LL_ENDL;
-			return true;
-		}
-		copy_inventory_item(
-			gAgent.getID(),
-			item->getPermissions().getOwner(),
-			item->getUUID(),
-			mDstCatID,
-			std::string(),
-			new LLBoostFuncInventoryCallback(boost::bind(&LLCallAfterInventoryBatchMgr::onOp,this,item_id,_1,LLTimer()))
-			);
-		return true;
-	}
-
-	static S32 getInstanceCount() { return sInstanceCount; }
-	
-private:
-	static S32 sInstanceCount;
-};
-
-S32 LLCallAfterInventoryCopyMgr::sInstanceCount = 0;
-
-class LLWearCategoryAfterCopy: public LLInventoryCallback
-{
-public:
-	LLWearCategoryAfterCopy(bool append):
-		mAppend(append)
-	{}
-
-	// virtual
-	void fire(const LLUUID& id)
-	{
-		// Wear the inventory category.
-		LLInventoryCategory* cat = gInventory.getCategory(id);
-		LLAppearanceMgr::instance().wearInventoryCategoryOnAvatar(cat, mAppend);
-	}
-
-private:
-	bool mAppend;
-};
-
-class LLTrackPhaseWrapper : public LLInventoryCallback
-{
-public:
-	LLTrackPhaseWrapper(const std::string& phase_name, LLPointer<LLInventoryCallback> cb = NULL):
-		mTrackingPhase(phase_name),
-		mCB(cb)
-	{
-		selfStartPhase(mTrackingPhase);
-	}
-
-	// virtual
-	void fire(const LLUUID& id)
-	{
-		if (mCB)
-		{
-			mCB->fire(id);
-		}
-	}
-
-	// virtual
-	~LLTrackPhaseWrapper()
-	{
-		selfStopPhase(mTrackingPhase);
-	}
-
-protected:
-	std::string mTrackingPhase;
-	LLPointer<LLInventoryCallback> mCB;
-};
-
-LLUpdateAppearanceOnDestroy::LLUpdateAppearanceOnDestroy(bool enforce_item_restrictions,
-														 bool enforce_ordering,
-														 nullary_func_t post_update_func 
-	):
-	mFireCount(0),
-	mEnforceItemRestrictions(enforce_item_restrictions),
-	mEnforceOrdering(enforce_ordering),
-	mPostUpdateFunc(post_update_func)
-{
-	selfStartPhase("update_appearance_on_destroy");
-}
-
-void LLUpdateAppearanceOnDestroy::fire(const LLUUID& inv_item)
-{
-	LLViewerInventoryItem* item = (LLViewerInventoryItem*)gInventory.getItem(inv_item);
-	const std::string item_name = item ? item->getName() : "ITEM NOT FOUND";
-#ifndef LL_RELEASE_FOR_DOWNLOAD
-	LL_DEBUGS("Avatar") << self_av_string() << "callback fired [ name:" << item_name << " UUID:" << inv_item << " count:" << mFireCount << " ] " << LL_ENDL;
-#endif
-	mFireCount++;
-}
-
-LLUpdateAppearanceOnDestroy::~LLUpdateAppearanceOnDestroy()
-{
-	if (!LLApp::isExiting())
-	{
-		// speculative fix for MAINT-1150
-		LL_INFOS("Avatar") << self_av_string() << "done update appearance on destroy" << LL_ENDL;
-
-		selfStopPhase("update_appearance_on_destroy");
-
-		LLAppearanceMgr::instance().updateAppearanceFromCOF(mEnforceItemRestrictions,
-															mEnforceOrdering,
-															mPostUpdateFunc);
-	}
-}
-
-LLUpdateAppearanceAndEditWearableOnDestroy::LLUpdateAppearanceAndEditWearableOnDestroy(const LLUUID& item_id):
-	mItemID(item_id)
-{
-}
-
-void edit_wearable_and_customize_avatar(LLUUID item_id)
-{
-	// Start editing the item if previously requested.
-	gAgentWearables.editWearableIfRequested(item_id);
-	
-	// TODO: camera mode may not be changed if a debug setting is tweaked
-	if( gAgentCamera.cameraCustomizeAvatar() )
-	{
-		// If we're in appearance editing mode, the current tab may need to be refreshed
-		LLSidepanelAppearance *panel = dynamic_cast<LLSidepanelAppearance*>(
-			LLFloaterSidePanelContainer::getPanel("appearance"));
-		if (panel)
-		{
-			panel->showDefaultSubpart();
-		}
-	}
-}
-
-LLUpdateAppearanceAndEditWearableOnDestroy::~LLUpdateAppearanceAndEditWearableOnDestroy()
-{
-	if (!LLApp::isExiting())
-	{
-		LLAppearanceMgr::instance().updateAppearanceFromCOF(
-			true,true,
-			boost::bind(edit_wearable_and_customize_avatar, mItemID));
-	}
-}
-
-
-struct LLFoundData
-{
-	LLFoundData() :
-		mAssetType(LLAssetType::AT_NONE),
-		mWearableType(LLWearableType::WT_INVALID),
-		mWearable(NULL) {}
-
-	LLFoundData(const LLUUID& item_id,
-				const LLUUID& asset_id,
-				const std::string& name,
-				const LLAssetType::EType& asset_type,
-				const LLWearableType::EType& wearable_type,
-				const bool is_replacement = false
-		) :
-		mItemID(item_id),
-		mAssetID(asset_id),
-		mName(name),
-		mAssetType(asset_type),
-		mWearableType(wearable_type),
-		mIsReplacement(is_replacement),
-		mWearable( NULL ) {}
-	
-	LLUUID mItemID;
-	LLUUID mAssetID;
-	std::string mName;
-	LLAssetType::EType mAssetType;
-	LLWearableType::EType mWearableType;
-	LLViewerWearable* mWearable;
-	bool mIsReplacement;
-};
-
-	
-class LLWearableHoldingPattern
-{
-	LOG_CLASS(LLWearableHoldingPattern);
-
-public:
-	LLWearableHoldingPattern();
-	~LLWearableHoldingPattern();
-
-	bool pollFetchCompletion();
-	void onFetchCompletion();
-	bool isFetchCompleted();
-	bool isTimedOut();
-
-	void checkMissingWearables();
-	bool pollMissingWearables();
-	bool isMissingCompleted();
-	void recoverMissingWearable(LLWearableType::EType type);
-	void clearCOFLinksForMissingWearables();
-	
-	void onWearableAssetFetch(LLViewerWearable *wearable);
-	void onAllComplete();
-
-	typedef std::list<LLFoundData> found_list_t;
-	found_list_t& getFoundList();
-	void eraseTypeToLink(LLWearableType::EType type);
-	void eraseTypeToRecover(LLWearableType::EType type);
-	void setObjItems(const LLInventoryModel::item_array_t& items);
-	void setGestItems(const LLInventoryModel::item_array_t& items);
-	bool isMostRecent();
-	void handleLateArrivals();
-	void resetTime(F32 timeout);
-	static S32 countActive() { return sActiveHoldingPatterns.size(); }
-	S32 index() { return mIndex; }
-	
-private:
-	found_list_t mFoundList;
-	LLInventoryModel::item_array_t mObjItems;
-	LLInventoryModel::item_array_t mGestItems;
-	typedef std::set<S32> type_set_t;
-	type_set_t mTypesToRecover;
-	type_set_t mTypesToLink;
-	S32 mResolved;
-	LLTimer mWaitTime;
-	bool mFired;
-	typedef std::set<LLWearableHoldingPattern*> type_set_hp;
-	static type_set_hp sActiveHoldingPatterns;
-	static S32 sNextIndex;
-	S32 mIndex;
-	bool mIsMostRecent;
-	std::set<LLViewerWearable*> mLateArrivals;
-	bool mIsAllComplete;
-};
-
-LLWearableHoldingPattern::type_set_hp LLWearableHoldingPattern::sActiveHoldingPatterns;
-S32 LLWearableHoldingPattern::sNextIndex = 0;
-
-LLWearableHoldingPattern::LLWearableHoldingPattern():
-	mResolved(0),
-	mFired(false),
-	mIsMostRecent(true),
-	mIsAllComplete(false)
-{
-	if (countActive()>0)
-	{
-		LL_INFOS() << "Creating LLWearableHoldingPattern when "
-				   << countActive()
-				   << " other attempts are active."
-				   << " Flagging others as invalid."
-				   << LL_ENDL;
-		for (type_set_hp::iterator it = sActiveHoldingPatterns.begin();
-			 it != sActiveHoldingPatterns.end();
-			 ++it)
-		{
-			(*it)->mIsMostRecent = false;
-		}
-			 
-	}
-	mIndex = sNextIndex++;
-	sActiveHoldingPatterns.insert(this);
-	LL_DEBUGS("Avatar") << "HP " << index() << " created" << LL_ENDL;
-	selfStartPhase("holding_pattern");
-}
-
-LLWearableHoldingPattern::~LLWearableHoldingPattern()
-{
-	sActiveHoldingPatterns.erase(this);
-	if (isMostRecent())
-	{
-		selfStopPhase("holding_pattern");
-	}
-	LL_DEBUGS("Avatar") << "HP " << index() << " deleted" << LL_ENDL;
-}
-
-bool LLWearableHoldingPattern::isMostRecent()
-{
-	return mIsMostRecent;
-}
-
-LLWearableHoldingPattern::found_list_t& LLWearableHoldingPattern::getFoundList()
-{
-	return mFoundList;
-}
-
-void LLWearableHoldingPattern::eraseTypeToLink(LLWearableType::EType type)
-{
-	mTypesToLink.erase(type);
-}
-
-void LLWearableHoldingPattern::eraseTypeToRecover(LLWearableType::EType type)
-{
-	mTypesToRecover.erase(type);
-}
-
-void LLWearableHoldingPattern::setObjItems(const LLInventoryModel::item_array_t& items)
-{
-	mObjItems = items;
-}
-
-void LLWearableHoldingPattern::setGestItems(const LLInventoryModel::item_array_t& items)
-{
-	mGestItems = items;
-}
-
-bool LLWearableHoldingPattern::isFetchCompleted()
-{
-	return (mResolved >= (S32)getFoundList().size()); // have everything we were waiting for?
-}
-
-bool LLWearableHoldingPattern::isTimedOut()
-{
-	return mWaitTime.hasExpired();
-}
-
-void LLWearableHoldingPattern::checkMissingWearables()
-{
-	if (!isMostRecent())
-	{
-		// runway why don't we actually skip here?
-		LL_WARNS() << self_av_string() << "skipping because LLWearableHolding pattern is invalid (superceded by later outfit request)" << LL_ENDL;
-	}
-
-	std::vector<S32> found_by_type(LLWearableType::WT_COUNT,0);
-	std::vector<S32> requested_by_type(LLWearableType::WT_COUNT,0);
-	for (found_list_t::iterator it = getFoundList().begin(); it != getFoundList().end(); ++it)
-	{
-		LLFoundData &data = *it;
-		if (data.mWearableType < LLWearableType::WT_COUNT)
-			requested_by_type[data.mWearableType]++;
-		if (data.mWearable)
-			found_by_type[data.mWearableType]++;
-	}
-
-	for (S32 type = 0; type < LLWearableType::WT_COUNT; ++type)
-	{
-		if (requested_by_type[type] > found_by_type[type])
-		{
-			LL_WARNS() << self_av_string() << "got fewer wearables than requested, type " << type << ": requested " << requested_by_type[type] << ", found " << found_by_type[type] << LL_ENDL;
-		}
-		if (found_by_type[type] > 0)
-			continue;
-		if (
-			// If at least one wearable of certain types (pants/shirt/skirt)
-			// was requested but none was found, create a default asset as a replacement.
-			// In all other cases, don't do anything.
-			// For critical types (shape/hair/skin/eyes), this will keep the avatar as a cloud 
-			// due to logic in LLVOAvatarSelf::getIsCloud().
-			// For non-critical types (tatoo, socks, etc.) the wearable will just be missing.
-			(requested_by_type[type] > 0) &&  
-			((type == LLWearableType::WT_PANTS) || (type == LLWearableType::WT_SHIRT) || (type == LLWearableType::WT_SKIRT)))
-		{
-			mTypesToRecover.insert(type);
-			mTypesToLink.insert(type);
-			recoverMissingWearable((LLWearableType::EType)type);
-			LL_WARNS() << self_av_string() << "need to replace " << type << LL_ENDL; 
-		}
-	}
-
-	resetTime(60.0F);
-
-	if (isMostRecent())
-	{
-		selfStartPhase("get_missing_wearables_2");
-	}
-	if (!pollMissingWearables())
-	{
-		doOnIdleRepeating(boost::bind(&LLWearableHoldingPattern::pollMissingWearables,this));
-	}
-}
-
-void LLWearableHoldingPattern::onAllComplete()
-{
-	if (isAgentAvatarValid())
-	{
-		gAgentAvatarp->outputRezTiming("Agent wearables fetch complete");
-	}
-
-	if (!isMostRecent())
-	{
-		// runway need to skip here?
-		LL_WARNS() << self_av_string() << "skipping because LLWearableHolding pattern is invalid (superceded by later outfit request)" << LL_ENDL;
-	}
-
-	// Activate all gestures in this folder
-	if (mGestItems.size() > 0)
-	{
-		LL_DEBUGS("Avatar") << self_av_string() << "Activating " << mGestItems.size() << " gestures" << LL_ENDL;
-		
-		LLGestureMgr::instance().activateGestures(mGestItems);
-		
-		// Update the inventory item labels to reflect the fact
-		// they are active.
-		LLViewerInventoryCategory* catp =
-			gInventory.getCategory(LLAppearanceMgr::instance().getCOF());
-		
-		if (catp)
-		{
-			gInventory.updateCategory(catp);
-			gInventory.notifyObservers();
-		}
-	}
-
-	if (isAgentAvatarValid())
-	{
-		LL_DEBUGS("Avatar") << self_av_string() << "Updating " << mObjItems.size() << " attachments" << LL_ENDL;
-		LLAgentWearables::llvo_vec_t objects_to_remove;
-		LLAgentWearables::llvo_vec_t objects_to_retain;
-		LLInventoryModel::item_array_t items_to_add;
-
-		LLAgentWearables::findAttachmentsAddRemoveInfo(mObjItems,
-													   objects_to_remove,
-													   objects_to_retain,
-													   items_to_add);
-
-		LL_DEBUGS("Avatar") << self_av_string() << "Removing " << objects_to_remove.size()
-							<< " attachments" << LL_ENDL;
-
-		// Here we remove the attachment pos overrides for *all*
-		// attachments, even those that are not being removed. This is
-		// needed to get joint positions all slammed down to their
-		// pre-attachment states.
-		gAgentAvatarp->clearAttachmentPosOverrides();
-
-		// Take off the attachments that will no longer be in the outfit.
-		LLAgentWearables::userRemoveMultipleAttachments(objects_to_remove);
-		
-		// Update wearables.
-		LL_INFOS("Avatar") << self_av_string() << "HP " << index() << " updating agent wearables with "
-						   << mResolved << " wearable items " << LL_ENDL;
-		LLAppearanceMgr::instance().updateAgentWearables(this);
-		
-		// Restore attachment pos overrides for the attachments that
-		// are remaining in the outfit.
-		for (LLAgentWearables::llvo_vec_t::iterator it = objects_to_retain.begin();
-			 it != objects_to_retain.end();
-			 ++it)
-		{
-			LLViewerObject *objectp = *it;
-			gAgentAvatarp->addAttachmentPosOverridesForObject(objectp);
-		}
-		
-		// Add new attachments to match those requested.
-		LL_DEBUGS("Avatar") << self_av_string() << "Adding " << items_to_add.size() << " attachments" << LL_ENDL;
-		LLAgentWearables::userAttachMultipleAttachments(items_to_add);
-	}
-
-	if (isFetchCompleted() && isMissingCompleted())
-	{
-		// Only safe to delete if all wearable callbacks and all missing wearables completed.
-		delete this;
-	}
-	else
-	{
-		mIsAllComplete = true;
-		handleLateArrivals();
-	}
-}
-
-void LLWearableHoldingPattern::onFetchCompletion()
-{
-	if (isMostRecent())
-	{
-		selfStopPhase("get_wearables_2");
-	}
-		
-	if (!isMostRecent())
-	{
-		// runway skip here?
-		LL_WARNS() << self_av_string() << "skipping because LLWearableHolding pattern is invalid (superceded by later outfit request)" << LL_ENDL;
-	}
-
-	checkMissingWearables();
-}
-
-// Runs as an idle callback until all wearables are fetched (or we time out).
-bool LLWearableHoldingPattern::pollFetchCompletion()
-{
-	if (!isMostRecent())
-	{
-		// runway skip here?
-		LL_WARNS() << self_av_string() << "skipping because LLWearableHolding pattern is invalid (superceded by later outfit request)" << LL_ENDL;
-	}
-
-	bool completed = isFetchCompleted();
-	bool timed_out = isTimedOut();
-	bool done = completed || timed_out;
-
-	if (done)
-	{
-		LL_INFOS("Avatar") << self_av_string() << "HP " << index() << " polling, done status: " << completed << " timed out " << timed_out
-				<< " elapsed " << mWaitTime.getElapsedTimeF32() << LL_ENDL;
-
-		mFired = true;
-		
-		if (timed_out)
-		{
-			LL_WARNS() << self_av_string() << "Exceeded max wait time for wearables, updating appearance based on what has arrived" << LL_ENDL;
-		}
-
-		onFetchCompletion();
-	}
-	return done;
-}
-
-void recovered_item_link_cb(const LLUUID& item_id, LLWearableType::EType type, LLViewerWearable *wearable, LLWearableHoldingPattern* holder)
-{
-	if (!holder->isMostRecent())
-	{
-		LL_WARNS() << "HP " << holder->index() << " skipping because LLWearableHolding pattern is invalid (superceded by later outfit request)" << LL_ENDL;
-		// runway skip here?
-	}
-
-	LL_INFOS() << "HP " << holder->index() << " recovered item link for type " << type << LL_ENDL;
-	holder->eraseTypeToLink(type);
-	// Add wearable to FoundData for actual wearing
-	LLViewerInventoryItem *item = gInventory.getItem(item_id);
-	LLViewerInventoryItem *linked_item = item ? item->getLinkedItem() : NULL;
-
-	if (linked_item)
-	{
-		gInventory.addChangedMask(LLInventoryObserver::LABEL, linked_item->getUUID());
-			
-		if (item)
-		{
-			LLFoundData found(linked_item->getUUID(),
-							  linked_item->getAssetUUID(),
-							  linked_item->getName(),
-							  linked_item->getType(),
-							  linked_item->isWearableType() ? linked_item->getWearableType() : LLWearableType::WT_INVALID,
-							  true // is replacement
-				);
-			found.mWearable = wearable;
-			holder->getFoundList().push_front(found);
-		}
-		else
-		{
-			LL_WARNS() << self_av_string() << "inventory link not found for recovered wearable" << LL_ENDL;
-		}
-	}
-	else
-	{
-		LL_WARNS() << self_av_string() << "HP " << holder->index() << " inventory link not found for recovered wearable" << LL_ENDL;
-	}
-}
-
-void recovered_item_cb(const LLUUID& item_id, LLWearableType::EType type, LLViewerWearable *wearable, LLWearableHoldingPattern* holder)
-{
-	if (!holder->isMostRecent())
-	{
-		// runway skip here?
-		LL_WARNS() << self_av_string() << "skipping because LLWearableHolding pattern is invalid (superceded by later outfit request)" << LL_ENDL;
-	}
-
-	LL_DEBUGS("Avatar") << self_av_string() << "Recovered item for type " << type << LL_ENDL;
-	LLConstPointer<LLInventoryObject> itemp = gInventory.getItem(item_id);
-	wearable->setItemID(item_id);
-	holder->eraseTypeToRecover(type);
-	llassert(itemp);
-	if (itemp)
-	{
-		LLPointer<LLInventoryCallback> cb = new LLBoostFuncInventoryCallback(boost::bind(recovered_item_link_cb,_1,type,wearable,holder));
-
-		link_inventory_object(LLAppearanceMgr::instance().getCOF(), itemp, cb);
-	}
-}
-
-void LLWearableHoldingPattern::recoverMissingWearable(LLWearableType::EType type)
-{
-	if (!isMostRecent())
-	{
-		// runway skip here?
-		LL_WARNS() << self_av_string() << "skipping because LLWearableHolding pattern is invalid (superceded by later outfit request)" << LL_ENDL;
-	}
-	
-		// Try to recover by replacing missing wearable with a new one.
-	LLNotificationsUtil::add("ReplacedMissingWearable");
-	LL_DEBUGS() << "Wearable " << LLWearableType::getTypeLabel(type)
-				<< " could not be downloaded.  Replaced inventory item with default wearable." << LL_ENDL;
-	LLViewerWearable* wearable = LLWearableList::instance().createNewWearable(type, gAgentAvatarp);
-
-	// Add a new one in the lost and found folder.
-	const LLUUID lost_and_found_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LOST_AND_FOUND);
-	LLPointer<LLInventoryCallback> cb = new LLBoostFuncInventoryCallback(boost::bind(recovered_item_cb,_1,type,wearable,this));
-
-	create_inventory_item(gAgent.getID(),
-						  gAgent.getSessionID(),
-						  lost_and_found_id,
-						  wearable->getTransactionID(),
-						  wearable->getName(),
-						  wearable->getDescription(),
-						  wearable->getAssetType(),
-						  LLInventoryType::IT_WEARABLE,
-						  wearable->getType(),
-						  wearable->getPermissions().getMaskNextOwner(),
-						  cb);
-}
-
-bool LLWearableHoldingPattern::isMissingCompleted()
-{
-	return mTypesToLink.size()==0 && mTypesToRecover.size()==0;
-}
-
-void LLWearableHoldingPattern::clearCOFLinksForMissingWearables()
-{
-	for (found_list_t::iterator it = getFoundList().begin(); it != getFoundList().end(); ++it)
-	{
-		LLFoundData &data = *it;
-		if ((data.mWearableType < LLWearableType::WT_COUNT) && (!data.mWearable))
-		{
-			// Wearable link that was never resolved; remove links to it from COF
-			LL_INFOS("Avatar") << self_av_string() << "HP " << index() << " removing link for unresolved item " << data.mItemID.asString() << LL_ENDL;
-			LLAppearanceMgr::instance().removeCOFItemLinks(data.mItemID);
-		}
-	}
-}
-
-bool LLWearableHoldingPattern::pollMissingWearables()
-{
-	if (!isMostRecent())
-	{
-		// runway skip here?
-		LL_WARNS() << self_av_string() << "skipping because LLWearableHolding pattern is invalid (superceded by later outfit request)" << LL_ENDL;
-	}
-	
-	bool timed_out = isTimedOut();
-	bool missing_completed = isMissingCompleted();
-	bool done = timed_out || missing_completed;
-
-	if (!done)
-	{
-		LL_INFOS("Avatar") << self_av_string() << "HP " << index() << " polling missing wearables, waiting for items " << mTypesToRecover.size()
-				<< " links " << mTypesToLink.size()
-				<< " wearables, timed out " << timed_out
-				<< " elapsed " << mWaitTime.getElapsedTimeF32()
-				<< " done " << done << LL_ENDL;
-	}
-
-	if (done)
-	{
-		if (isMostRecent())
-		{
-			selfStopPhase("get_missing_wearables_2");
-		}
-
-		gAgentAvatarp->debugWearablesLoaded();
-
-		// BAP - if we don't call clearCOFLinksForMissingWearables()
-		// here, we won't have to add the link back in later if the
-		// wearable arrives late.  This is to avoid corruption of
-		// wearable ordering info.  Also has the effect of making
-		// unworn item links visible in the COF under some
-		// circumstances.
-
-		//clearCOFLinksForMissingWearables();
-		onAllComplete();
-	}
-	return done;
-}
-
-// Handle wearables that arrived after the timeout period expired.
-void LLWearableHoldingPattern::handleLateArrivals()
-{
-	// Only safe to run if we have previously finished the missing
-	// wearables and other processing - otherwise we could be in some
-	// intermediate state - but have not been superceded by a later
-	// outfit change request.
-	if (mLateArrivals.size() == 0)
-	{
-		// Nothing to process.
-		return;
-	}
-	if (!isMostRecent())
-	{
-		LL_WARNS() << self_av_string() << "Late arrivals not handled - outfit change no longer valid" << LL_ENDL;
-	}
-	if (!mIsAllComplete)
-	{
-		LL_WARNS() << self_av_string() << "Late arrivals not handled - in middle of missing wearables processing" << LL_ENDL;
-	}
-
-	LL_INFOS("Avatar") << self_av_string() << "HP " << index() << " need to handle " << mLateArrivals.size() << " late arriving wearables" << LL_ENDL;
-
-	// Update mFoundList using late-arriving wearables.
-	std::set<LLWearableType::EType> replaced_types;
-	for (LLWearableHoldingPattern::found_list_t::iterator iter = getFoundList().begin();
-		 iter != getFoundList().end(); ++iter)
-	{
-		LLFoundData& data = *iter;
-		for (std::set<LLViewerWearable*>::iterator wear_it = mLateArrivals.begin();
-			 wear_it != mLateArrivals.end();
-			 ++wear_it)
-		{
-			LLViewerWearable *wearable = *wear_it;
-
-			if(wearable->getAssetID() == data.mAssetID)
-			{
-				data.mWearable = wearable;
-
-				replaced_types.insert(data.mWearableType);
-
-				// BAP - if we didn't call
-				// clearCOFLinksForMissingWearables() earlier, we
-				// don't need to restore the link here.  Fixes
-				// wearable ordering problems.
-
-				// LLAppearanceMgr::instance().addCOFItemLink(data.mItemID,false);
-
-				// BAP failing this means inventory or asset server
-				// are corrupted in a way we don't handle.
-				llassert((data.mWearableType < LLWearableType::WT_COUNT) && (wearable->getType() == data.mWearableType));
-				break;
-			}
-		}
-	}
-
-	// Remove COF links for any default wearables previously used to replace the late arrivals.
-	// All this pussyfooting around with a while loop and explicit
-	// iterator incrementing is to allow removing items from the list
-	// without clobbering the iterator we're using to navigate.
-	LLWearableHoldingPattern::found_list_t::iterator iter = getFoundList().begin();
-	while (iter != getFoundList().end())
-	{
-		LLFoundData& data = *iter;
-
-		// If an item of this type has recently shown up, removed the corresponding replacement wearable from COF.
-		if (data.mWearable && data.mIsReplacement &&
-			replaced_types.find(data.mWearableType) != replaced_types.end())
-		{
-			LLAppearanceMgr::instance().removeCOFItemLinks(data.mItemID);
-			std::list<LLFoundData>::iterator clobber_ator = iter;
-			++iter;
-			getFoundList().erase(clobber_ator);
-		}
-		else
-		{
-			++iter;
-		}
-	}
-
-	// Clear contents of late arrivals.
-	mLateArrivals.clear();
-
-	// Update appearance based on mFoundList
-	LLAppearanceMgr::instance().updateAgentWearables(this);
-}
-
-void LLWearableHoldingPattern::resetTime(F32 timeout)
-{
-	mWaitTime.reset();
-	mWaitTime.setTimerExpirySec(timeout);
-}
-
-void LLWearableHoldingPattern::onWearableAssetFetch(LLViewerWearable *wearable)
-{
-	if (!isMostRecent())
-	{
-		LL_WARNS() << self_av_string() << "skipping because LLWearableHolding pattern is invalid (superceded by later outfit request)" << LL_ENDL;
-	}
-	
-	mResolved += 1;  // just counting callbacks, not successes.
-	LL_DEBUGS("Avatar") << self_av_string() << "HP " << index() << " resolved " << mResolved << "/" << getFoundList().size() << LL_ENDL;
-	if (!wearable)
-	{
-		LL_WARNS() << self_av_string() << "no wearable found" << LL_ENDL;
-	}
-
-	if (mFired)
-	{
-		LL_WARNS() << self_av_string() << "called after holder fired" << LL_ENDL;
-		if (wearable)
-		{
-			mLateArrivals.insert(wearable);
-			if (mIsAllComplete)
-			{
-				handleLateArrivals();
-			}
-		}
-		return;
-	}
-
-	if (!wearable)
-	{
-		return;
-	}
-
-	for (LLWearableHoldingPattern::found_list_t::iterator iter = getFoundList().begin();
-		 iter != getFoundList().end(); ++iter)
-	{
-		LLFoundData& data = *iter;
-		if(wearable->getAssetID() == data.mAssetID)
-		{
-			// Failing this means inventory or asset server are corrupted in a way we don't handle.
-			if ((data.mWearableType >= LLWearableType::WT_COUNT) || (wearable->getType() != data.mWearableType))
-			{
-				LL_WARNS() << self_av_string() << "recovered wearable but type invalid. inventory wearable type: " << data.mWearableType << " asset wearable type: " << wearable->getType() << LL_ENDL;
-				break;
-			}
-
-			data.mWearable = wearable;
-		}
-	}
-}
-
-static void onWearableAssetFetch(LLViewerWearable* wearable, void* data)
-{
-	LLWearableHoldingPattern* holder = (LLWearableHoldingPattern*)data;
-	holder->onWearableAssetFetch(wearable);
-}
-
-
-static void removeDuplicateItems(LLInventoryModel::item_array_t& items)
-{
-	LLInventoryModel::item_array_t new_items;
-	std::set<LLUUID> items_seen;
-	std::deque<LLViewerInventoryItem*> tmp_list;
-	// Traverse from the front and keep the first of each item
-	// encountered, so we actually keep the *last* of each duplicate
-	// item.  This is needed to give the right priority when adding
-	// duplicate items to an existing outfit.
-	for (S32 i=items.size()-1; i>=0; i--)
-	{
-		LLViewerInventoryItem *item = items.at(i);
-		LLUUID item_id = item->getLinkedUUID();
-		if (items_seen.find(item_id)!=items_seen.end())
-			continue;
-		items_seen.insert(item_id);
-		tmp_list.push_front(item);
-	}
-	for (std::deque<LLViewerInventoryItem*>::iterator it = tmp_list.begin();
-		 it != tmp_list.end();
-		 ++it)
-	{
-		new_items.push_back(*it);
-	}
-	items = new_items;
-}
-
-const LLUUID LLAppearanceMgr::getCOF() const
-{
-	return gInventory.findCategoryUUIDForType(LLFolderType::FT_CURRENT_OUTFIT);
-}
-
-S32 LLAppearanceMgr::getCOFVersion() const
-{
-	LLViewerInventoryCategory *cof = gInventory.getCategory(getCOF());
-	if (cof)
-	{
-		return cof->getVersion();
-	}
-	else
-	{
-		return LLViewerInventoryCategory::VERSION_UNKNOWN;
-	}
-}
-
-const LLViewerInventoryItem* LLAppearanceMgr::getBaseOutfitLink()
-{
-	const LLUUID& current_outfit_cat = getCOF();
-	LLInventoryModel::cat_array_t cat_array;
-	LLInventoryModel::item_array_t item_array;
-	// Can't search on FT_OUTFIT since links to categories return FT_CATEGORY for type since they don't
-	// return preferred type.
-	LLIsType is_category( LLAssetType::AT_CATEGORY ); 
-	gInventory.collectDescendentsIf(current_outfit_cat,
-									cat_array,
-									item_array,
-									false,
-									is_category);
-	for (LLInventoryModel::item_array_t::const_iterator iter = item_array.begin();
-		 iter != item_array.end();
-		 iter++)
-	{
-		const LLViewerInventoryItem *item = (*iter);
-		const LLViewerInventoryCategory *cat = item->getLinkedCategory();
-		if (cat && cat->getPreferredType() == LLFolderType::FT_OUTFIT)
-		{
-			const LLUUID parent_id = cat->getParentUUID();
-			LLViewerInventoryCategory*  parent_cat =  gInventory.getCategory(parent_id);
-			// if base outfit moved to trash it means that we don't have base outfit
-			if (parent_cat != NULL && parent_cat->getPreferredType() == LLFolderType::FT_TRASH)
-			{
-				return NULL;
-			}
-			return item;
-		}
-	}
-	return NULL;
-}
-
-bool LLAppearanceMgr::getBaseOutfitName(std::string& name)
-{
-	const LLViewerInventoryItem* outfit_link = getBaseOutfitLink();
-	if(outfit_link)
-	{
-		const LLViewerInventoryCategory *cat = outfit_link->getLinkedCategory();
-		if (cat)
-		{
-			name = cat->getName();
-			return true;
-		}
-	}
-	return false;
-}
-
-const LLUUID LLAppearanceMgr::getBaseOutfitUUID()
-{
-	const LLViewerInventoryItem* outfit_link = getBaseOutfitLink();
-	if (!outfit_link || !outfit_link->getIsLinkType()) return LLUUID::null;
-
-	const LLViewerInventoryCategory* outfit_cat = outfit_link->getLinkedCategory();
-	if (!outfit_cat) return LLUUID::null;
-
-	if (outfit_cat->getPreferredType() != LLFolderType::FT_OUTFIT)
-	{
-		LL_WARNS() << "Expected outfit type:" << LLFolderType::FT_OUTFIT << " but got type:" << outfit_cat->getType() << " for folder name:" << outfit_cat->getName() << LL_ENDL;
-		return LLUUID::null;
-	}
-
-	return outfit_cat->getUUID();
-}
-
-void wear_on_avatar_cb(const LLUUID& inv_item, bool do_replace = false)
-{
-	if (inv_item.isNull())
-		return;
-	
-	LLViewerInventoryItem *item = gInventory.getItem(inv_item);
-	if (item)
-	{
-		LLAppearanceMgr::instance().wearItemOnAvatar(inv_item, true, do_replace);
-	}
-}
-
-bool LLAppearanceMgr::wearItemOnAvatar(const LLUUID& item_id_to_wear,
-									   bool do_update,
-									   bool replace,
-									   LLPointer<LLInventoryCallback> cb)
-{
-
-	if (item_id_to_wear.isNull()) return false;
-
-	// *TODO: issue with multi-wearable should be fixed:
-	// in this case this method will be called N times - loading started for each item
-	// and than N times will be called - loading completed for each item.
-	// That means subscribers will be notified that loading is done after first item in a batch is worn.
-	// (loading indicator disappears for example before all selected items are worn)
-	// Have not fix this issue for 2.1 because of stability reason. EXT-7777.
-
-	// Disabled for now because it is *not* acceptable to call updateAppearanceFromCOF() multiple times
-//	gAgentWearables.notifyLoadingStarted();
-
-	LLViewerInventoryItem* item_to_wear = gInventory.getItem(item_id_to_wear);
-	if (!item_to_wear) return false;
-
-	if (gInventory.isObjectDescendentOf(item_to_wear->getUUID(), gInventory.getLibraryRootFolderID()))
-	{
-		LLPointer<LLInventoryCallback> cb = new LLBoostFuncInventoryCallback(boost::bind(wear_on_avatar_cb,_1,replace));
-		copy_inventory_item(gAgent.getID(), item_to_wear->getPermissions().getOwner(), item_to_wear->getUUID(), LLUUID::null, std::string(), cb);
-		return false;
-	} 
-	else if (!gInventory.isObjectDescendentOf(item_to_wear->getUUID(), gInventory.getRootFolderID()))
-	{
-		return false; // not in library and not in agent's inventory
-	}
-	else if (gInventory.isObjectDescendentOf(item_to_wear->getUUID(), gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH)))
-	{
-		LLNotificationsUtil::add("CannotWearTrash");
-		return false;
-	}
-	else if (isLinkedInCOF(item_to_wear->getUUID())) // EXT-84911
-	{
-		return false;
-	}
-
-	switch (item_to_wear->getType())
-	{
-		case LLAssetType::AT_CLOTHING:
-		if (gAgentWearables.areWearablesLoaded())
-		{
-			if (!cb && do_update)
-			{
-				cb = new LLUpdateAppearanceAndEditWearableOnDestroy(item_id_to_wear);
-			}
-			S32 wearable_count = gAgentWearables.getWearableCount(item_to_wear->getWearableType());
-			if ((replace && wearable_count != 0) ||
-				(wearable_count >= LLAgentWearables::MAX_CLOTHING_PER_TYPE) )
-			{
-				LLUUID item_id = gAgentWearables.getWearableItemID(item_to_wear->getWearableType(),
-																   wearable_count-1);
-				removeCOFItemLinks(item_id, cb);
-			}
-
-			addCOFItemLink(item_to_wear, cb);
-		} 
-		break;
-
-		case LLAssetType::AT_BODYPART:
-		// TODO: investigate wearables may not be loaded at this point EXT-8231
-		
-		// Remove the existing wearables of the same type.
-		// Remove existing body parts anyway because we must not be able to wear e.g. two skins.
-		removeCOFLinksOfType(item_to_wear->getWearableType());
-		if (!cb && do_update)
-		{
-			cb = new LLUpdateAppearanceAndEditWearableOnDestroy(item_id_to_wear);
-		}
-		addCOFItemLink(item_to_wear, cb);
-		break;
-
-		case LLAssetType::AT_OBJECT:
-		rez_attachment(item_to_wear, NULL, replace);
-		break;
-
-		default: return false;;
-	}
-
-	return true;
-}
-
-// Update appearance from outfit folder.
-void LLAppearanceMgr::changeOutfit(bool proceed, const LLUUID& category, bool append)
-{
-	if (!proceed)
-		return;
-	LLAppearanceMgr::instance().updateCOF(category,append);
-}
-
-void LLAppearanceMgr::replaceCurrentOutfit(const LLUUID& new_outfit)
-{
-	LLViewerInventoryCategory* cat = gInventory.getCategory(new_outfit);
-	wearInventoryCategory(cat, false, false);
-}
-
-// Open outfit renaming dialog.
-void LLAppearanceMgr::renameOutfit(const LLUUID& outfit_id)
-{
-	LLViewerInventoryCategory* cat = gInventory.getCategory(outfit_id);
-	if (!cat)
-	{
-		return;
-	}
-
-	LLSD args;
-	args["NAME"] = cat->getName();
-
-	LLSD payload;
-	payload["cat_id"] = outfit_id;
-
-	LLNotificationsUtil::add("RenameOutfit", args, payload, boost::bind(onOutfitRename, _1, _2));
-}
-
-// User typed new outfit name.
-// static
-void LLAppearanceMgr::onOutfitRename(const LLSD& notification, const LLSD& response)
-{
-	S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
-	if (option != 0) return; // canceled
-
-	std::string outfit_name = response["new_name"].asString();
-	LLStringUtil::trim(outfit_name);
-	if (!outfit_name.empty())
-	{
-		LLUUID cat_id = notification["payload"]["cat_id"].asUUID();
-		rename_category(&gInventory, cat_id, outfit_name);
-	}
-}
-
-void LLAppearanceMgr::setOutfitLocked(bool locked)
-{
-	if (mOutfitLocked == locked)
-	{
-		return;
-	}
-
-	mOutfitLocked = locked;
-	if (locked)
-	{
-		mUnlockOutfitTimer->reset();
-		mUnlockOutfitTimer->start();
-	}
-	else
-	{
-		mUnlockOutfitTimer->stop();
-	}
-
-	LLOutfitObserver::instance().notifyOutfitLockChanged();
-}
-
-void LLAppearanceMgr::addCategoryToCurrentOutfit(const LLUUID& cat_id)
-{
-	LLViewerInventoryCategory* cat = gInventory.getCategory(cat_id);
-	wearInventoryCategory(cat, false, true);
-}
-
-void LLAppearanceMgr::takeOffOutfit(const LLUUID& cat_id)
-{
-	LLInventoryModel::cat_array_t cats;
-	LLInventoryModel::item_array_t items;
-	LLFindWearablesEx collector(/*is_worn=*/ true, /*include_body_parts=*/ false);
-
-	gInventory.collectDescendentsIf(cat_id, cats, items, FALSE, collector);
-
-	LLInventoryModel::item_array_t::const_iterator it = items.begin();
-	const LLInventoryModel::item_array_t::const_iterator it_end = items.end();
-	uuid_vec_t uuids_to_remove;
-	for( ; it_end != it; ++it)
-	{
-		LLViewerInventoryItem* item = *it;
-		uuids_to_remove.push_back(item->getUUID());
-	}
-	removeItemsFromAvatar(uuids_to_remove);
-
-	// deactivate all gestures in the outfit folder
-	LLInventoryModel::item_array_t gest_items;
-	getDescendentsOfAssetType(cat_id, gest_items, LLAssetType::AT_GESTURE);
-	for(S32 i = 0; i  < gest_items.size(); ++i)
-	{
-		LLViewerInventoryItem *gest_item = gest_items[i];
-		if ( LLGestureMgr::instance().isGestureActive( gest_item->getLinkedUUID()) )
-		{
-			LLGestureMgr::instance().deactivateGesture( gest_item->getLinkedUUID() );
-		}
-	}
-}
-
-// Create a copy of src_id + contents as a subfolder of dst_id.
-void LLAppearanceMgr::shallowCopyCategory(const LLUUID& src_id, const LLUUID& dst_id,
-											  LLPointer<LLInventoryCallback> cb)
-{
-	LLInventoryCategory *src_cat = gInventory.getCategory(src_id);
-	if (!src_cat)
-	{
-		LL_WARNS() << "folder not found for src " << src_id.asString() << LL_ENDL;
-		return;
-	}
-	LL_INFOS() << "starting, src_id " << src_id << " name " << src_cat->getName() << " dst_id " << dst_id << LL_ENDL;
-	LLUUID parent_id = dst_id;
-	if(parent_id.isNull())
-	{
-		parent_id = gInventory.getRootFolderID();
-	}
-	LLUUID subfolder_id = gInventory.createNewCategory( parent_id,
-														LLFolderType::FT_NONE,
-														src_cat->getName());
-	shallowCopyCategoryContents(src_id, subfolder_id, cb);
-
-	gInventory.notifyObservers();
-}
-
-void LLAppearanceMgr::slamCategoryLinks(const LLUUID& src_id, const LLUUID& dst_id,
-										bool include_folder_links, LLPointer<LLInventoryCallback> cb)
-{
-	LLInventoryModel::cat_array_t* cats;
-	LLInventoryModel::item_array_t* items;
-	LLSD contents = LLSD::emptyArray();
-	gInventory.getDirectDescendentsOf(src_id, cats, items);
-	LL_INFOS() << "copying " << items->size() << " items" << LL_ENDL;
-	for (LLInventoryModel::item_array_t::const_iterator iter = items->begin();
-		 iter != items->end();
-		 ++iter)
-	{
-		const LLViewerInventoryItem* item = (*iter);
-		switch (item->getActualType())
-		{
-			case LLAssetType::AT_LINK:
-			{
-				LL_DEBUGS("Avatar") << "linking inventory item " << item->getName() << LL_ENDL;
-				//getActualDescription() is used for a new description 
-				//to propagate ordering information saved in descriptions of links
-				LLSD item_contents;
-				item_contents["name"] = item->getName();
-				item_contents["desc"] = item->getActualDescription();
-				item_contents["linked_id"] = item->getLinkedUUID();
-				item_contents["type"] = LLAssetType::AT_LINK; 
-				contents.append(item_contents);
-				break;
-			}
-			case LLAssetType::AT_LINK_FOLDER:
-			{
-				LLViewerInventoryCategory *catp = item->getLinkedCategory();
-				if (catp && include_folder_links)
-				{
-					LL_DEBUGS("Avatar") << "linking inventory folder " << item->getName() << LL_ENDL;
-					LLSD base_contents;
-					base_contents["name"] = catp->getName();
-					base_contents["desc"] = ""; // categories don't have descriptions.
-					base_contents["linked_id"] = catp->getLinkedUUID();
-					base_contents["type"] = LLAssetType::AT_LINK_FOLDER; 
-					contents.append(base_contents);
-				}
-				break;
-			}
-			default:
-			{
-				// Linux refuses to compile unless all possible enums are handled. Really, Linux?
-				break;
-			}
-		}
-	}
-	slam_inventory_folder(dst_id, contents, cb);
-}
-// Copy contents of src_id to dst_id.
-void LLAppearanceMgr::shallowCopyCategoryContents(const LLUUID& src_id, const LLUUID& dst_id,
-													  LLPointer<LLInventoryCallback> cb)
-{
-	LLInventoryModel::cat_array_t* cats;
-	LLInventoryModel::item_array_t* items;
-	gInventory.getDirectDescendentsOf(src_id, cats, items);
-	LL_INFOS() << "copying " << items->size() << " items" << LL_ENDL;
-	LLInventoryObject::const_object_list_t link_array;
-	for (LLInventoryModel::item_array_t::const_iterator iter = items->begin();
-		 iter != items->end();
-		 ++iter)
-	{
-		const LLViewerInventoryItem* item = (*iter);
-		switch (item->getActualType())
-		{
-			case LLAssetType::AT_LINK:
-			{
-				LL_DEBUGS("Avatar") << "linking inventory item " << item->getName() << LL_ENDL;
-				link_array.push_back(LLConstPointer<LLInventoryObject>(item));
-				break;
-			}
-			case LLAssetType::AT_LINK_FOLDER:
-			{
-				LLViewerInventoryCategory *catp = item->getLinkedCategory();
-				// Skip copying outfit links.
-				if (catp && catp->getPreferredType() != LLFolderType::FT_OUTFIT)
-				{
-					LL_DEBUGS("Avatar") << "linking inventory folder " << item->getName() << LL_ENDL;
-					link_array.push_back(LLConstPointer<LLInventoryObject>(item));
-				}
-				break;
-			}
-			case LLAssetType::AT_CLOTHING:
-			case LLAssetType::AT_OBJECT:
-			case LLAssetType::AT_BODYPART:
-			case LLAssetType::AT_GESTURE:
-			{
-				LL_DEBUGS("Avatar") << "copying inventory item " << item->getName() << LL_ENDL;
-				copy_inventory_item(gAgent.getID(),
-									item->getPermissions().getOwner(),
-									item->getUUID(),
-									dst_id,
-									item->getName(),
-									cb);
-				break;
-			}
-			default:
-				// Ignore non-outfit asset types
-				break;
-		}
-	}
-	if (!link_array.empty())
-	{
-		link_inventory_array(dst_id, link_array, cb);
-	}
-}
-
-BOOL LLAppearanceMgr::getCanMakeFolderIntoOutfit(const LLUUID& folder_id)
-{
-	// These are the wearable items that are required for considering this
-	// folder as containing a complete outfit.
-	U32 required_wearables = 0;
-	required_wearables |= 1LL << LLWearableType::WT_SHAPE;
-	required_wearables |= 1LL << LLWearableType::WT_SKIN;
-	required_wearables |= 1LL << LLWearableType::WT_HAIR;
-	required_wearables |= 1LL << LLWearableType::WT_EYES;
-
-	// These are the wearables that the folder actually contains.
-	U32 folder_wearables = 0;
-	LLInventoryModel::cat_array_t* cats;
-	LLInventoryModel::item_array_t* items;
-	gInventory.getDirectDescendentsOf(folder_id, cats, items);
-	for (LLInventoryModel::item_array_t::const_iterator iter = items->begin();
-		 iter != items->end();
-		 ++iter)
-	{
-		const LLViewerInventoryItem* item = (*iter);
-		if (item->isWearableType())
-		{
-			const LLWearableType::EType wearable_type = item->getWearableType();
-			folder_wearables |= 1LL << wearable_type;
-		}
-	}
-
-	// If the folder contains the required wearables, return TRUE.
-	return ((required_wearables & folder_wearables) == required_wearables);
-}
-
-bool LLAppearanceMgr::getCanRemoveOutfit(const LLUUID& outfit_cat_id)
-{
-	// Disallow removing the base outfit.
-	if (outfit_cat_id == getBaseOutfitUUID())
-	{
-		return false;
-	}
-
-	// Check if the outfit folder itself is removable.
-	if (!get_is_category_removable(&gInventory, outfit_cat_id))
-	{
-		return false;
-	}
-
-	// Check for the folder's non-removable descendants.
-	LLFindNonRemovableObjects filter_non_removable;
-	LLInventoryModel::cat_array_t cats;
-	LLInventoryModel::item_array_t items;
-	LLInventoryModel::item_array_t::const_iterator it;
-	gInventory.collectDescendentsIf(outfit_cat_id, cats, items, false, filter_non_removable);
-	if (!cats.empty() || !items.empty())
-	{
-		return false;
-	}
-
-	return true;
-}
-
-// static
-bool LLAppearanceMgr::getCanRemoveFromCOF(const LLUUID& outfit_cat_id)
-{
-	if (gAgentWearables.isCOFChangeInProgress())
-	{
-		return false;
-	}
-
-	LLFindWearablesEx is_worn(/*is_worn=*/ true, /*include_body_parts=*/ false);
-	return gInventory.hasMatchingDirectDescendent(outfit_cat_id, is_worn);
-}
-
-// static
-bool LLAppearanceMgr::getCanAddToCOF(const LLUUID& outfit_cat_id)
-{
-	if (gAgentWearables.isCOFChangeInProgress())
-	{
-		return false;
-	}
-
-	LLInventoryModel::cat_array_t cats;
-	LLInventoryModel::item_array_t items;
-	LLFindWearablesEx not_worn(/*is_worn=*/ false, /*include_body_parts=*/ false);
-	gInventory.collectDescendentsIf(outfit_cat_id,
-		cats,
-		items,
-		LLInventoryModel::EXCLUDE_TRASH,
-		not_worn);
-
-	return items.size() > 0;
-}
-
-bool LLAppearanceMgr::getCanReplaceCOF(const LLUUID& outfit_cat_id)
-{
-	// Don't allow wearing anything while we're changing appearance.
-	if (gAgentWearables.isCOFChangeInProgress())
-	{
-		return false;
-	}
-
-	// Check whether it's the base outfit.
-	if (outfit_cat_id.isNull() || outfit_cat_id == getBaseOutfitUUID())
-	{
-		return false;
-	}
-
-	// Check whether the outfit contains any wearables we aren't wearing already (STORM-702).
-	LLInventoryModel::cat_array_t cats;
-	LLInventoryModel::item_array_t items;
-	LLFindWearablesEx is_worn(/*is_worn=*/ false, /*include_body_parts=*/ true);
-	gInventory.collectDescendentsIf(outfit_cat_id,
-		cats,
-		items,
-		LLInventoryModel::EXCLUDE_TRASH,
-		is_worn);
-
-	return items.size() > 0;
-}
-
-void LLAppearanceMgr::purgeBaseOutfitLink(const LLUUID& category, LLPointer<LLInventoryCallback> cb)
-{
-	LLInventoryModel::cat_array_t cats;
-	LLInventoryModel::item_array_t items;
-	gInventory.collectDescendents(category, cats, items,
-								  LLInventoryModel::EXCLUDE_TRASH);
-	for (S32 i = 0; i < items.size(); ++i)
-	{
-		LLViewerInventoryItem *item = items.at(i);
-		if (item->getActualType() != LLAssetType::AT_LINK_FOLDER)
-			continue;
-		LLViewerInventoryCategory* catp = item->getLinkedCategory();
-		if(catp && catp->getPreferredType() == LLFolderType::FT_OUTFIT)
-		{
-			remove_inventory_item(item->getUUID(), cb);
-		}
-	}
-}
-
-// Keep the last N wearables of each type.  For viewer 2.0, N is 1 for
-// both body parts and clothing items.
-void LLAppearanceMgr::filterWearableItems(
-	LLInventoryModel::item_array_t& items, S32 max_per_type)
-{
-	// Divvy items into arrays by wearable type.
-	std::vector<LLInventoryModel::item_array_t> items_by_type(LLWearableType::WT_COUNT);
-	divvyWearablesByType(items, items_by_type);
-
-	// rebuild items list, retaining the last max_per_type of each array
-	items.clear();
-	for (S32 i=0; i<LLWearableType::WT_COUNT; i++)
-	{
-		S32 size = items_by_type[i].size();
-		if (size <= 0)
-			continue;
-		S32 start_index = llmax(0,size-max_per_type);
-		for (S32 j = start_index; j<size; j++)
-		{
-			items.push_back(items_by_type[i][j]);
-		}
-	}
-}
-
-void LLAppearanceMgr::updateCOF(const LLUUID& category, bool append)
-{
-	LLViewerInventoryCategory *pcat = gInventory.getCategory(category);
-	if (!pcat)
-	{
-		LL_WARNS() << "no category found for id " << category << LL_ENDL;
-		return;
-	}
-	LL_INFOS("Avatar") << self_av_string() << "starting, cat '" << (pcat ? pcat->getName() : "[UNKNOWN]") << "'" << LL_ENDL;
-
-	const LLUUID cof = getCOF();
-
-	// Deactivate currently active gestures in the COF, if replacing outfit
-	if (!append)
-	{
-		LLInventoryModel::item_array_t gest_items;
-		getDescendentsOfAssetType(cof, gest_items, LLAssetType::AT_GESTURE);
-		for(S32 i = 0; i  < gest_items.size(); ++i)
-		{
-			LLViewerInventoryItem *gest_item = gest_items.at(i);
-			if ( LLGestureMgr::instance().isGestureActive( gest_item->getLinkedUUID()) )
-			{
-				LLGestureMgr::instance().deactivateGesture( gest_item->getLinkedUUID() );
-			}
-		}
-	}
-	
-	// Collect and filter descendents to determine new COF contents.
-
-	// - Body parts: always include COF contents as a fallback in case any
-	// required parts are missing.
-	// Preserve body parts from COF if appending.
-	LLInventoryModel::item_array_t body_items;
-	getDescendentsOfAssetType(cof, body_items, LLAssetType::AT_BODYPART);
-	getDescendentsOfAssetType(category, body_items, LLAssetType::AT_BODYPART);
-	if (append)
-		reverse(body_items.begin(), body_items.end());
-	// Reduce body items to max of one per type.
-	removeDuplicateItems(body_items);
-	filterWearableItems(body_items, 1);
-
-	// - Wearables: include COF contents only if appending.
-	LLInventoryModel::item_array_t wear_items;
-	if (append)
-		getDescendentsOfAssetType(cof, wear_items, LLAssetType::AT_CLOTHING);
-	getDescendentsOfAssetType(category, wear_items, LLAssetType::AT_CLOTHING);
-	// Reduce wearables to max of one per type.
-	removeDuplicateItems(wear_items);
-	filterWearableItems(wear_items, LLAgentWearables::MAX_CLOTHING_PER_TYPE);
-
-	// - Attachments: include COF contents only if appending.
-	LLInventoryModel::item_array_t obj_items;
-	if (append)
-		getDescendentsOfAssetType(cof, obj_items, LLAssetType::AT_OBJECT);
-	getDescendentsOfAssetType(category, obj_items, LLAssetType::AT_OBJECT);
-	removeDuplicateItems(obj_items);
-
-	// - Gestures: include COF contents only if appending.
-	LLInventoryModel::item_array_t gest_items;
-	if (append)
-		getDescendentsOfAssetType(cof, gest_items, LLAssetType::AT_GESTURE);
-	getDescendentsOfAssetType(category, gest_items, LLAssetType::AT_GESTURE);
-	removeDuplicateItems(gest_items);
-	
-	// Create links to new COF contents.
-	LLInventoryModel::item_array_t all_items;
-	std::copy(body_items.begin(), body_items.end(), std::back_inserter(all_items));
-	std::copy(wear_items.begin(), wear_items.end(), std::back_inserter(all_items));
-	std::copy(obj_items.begin(), obj_items.end(), std::back_inserter(all_items));
-	std::copy(gest_items.begin(), gest_items.end(), std::back_inserter(all_items));
-
-	// Find any wearables that need description set to enforce ordering.
-	desc_map_t desc_map;
-	getWearableOrderingDescUpdates(wear_items, desc_map);
-
-	// Will link all the above items.
-	// link_waiter enforce flags are false because we've already fixed everything up in updateCOF().
-	LLPointer<LLInventoryCallback> link_waiter = new LLUpdateAppearanceOnDestroy(false,false);
-	LLSD contents = LLSD::emptyArray();
-
-	for (LLInventoryModel::item_array_t::const_iterator it = all_items.begin();
-		 it != all_items.end(); ++it)
-	{
-		LLSD item_contents;
-		LLInventoryItem *item = *it;
-
-		std::string desc;
-		desc_map_t::const_iterator desc_iter = desc_map.find(item->getUUID());
-		if (desc_iter != desc_map.end())
-		{
-			desc = desc_iter->second;
-			LL_DEBUGS("Avatar") << item->getName() << " overriding desc to: " << desc
-								<< " (was: " << item->getActualDescription() << ")" << LL_ENDL;
-		}
-		else
-		{
-			desc = item->getActualDescription();
-		}
-
-		item_contents["name"] = item->getName();
-		item_contents["desc"] = desc;
-		item_contents["linked_id"] = item->getLinkedUUID();
-		item_contents["type"] = LLAssetType::AT_LINK; 
-		contents.append(item_contents);
-	}
-	const LLUUID& base_id = append ? getBaseOutfitUUID() : category;
-	LLViewerInventoryCategory *base_cat = gInventory.getCategory(base_id);
-	if (base_cat)
-	{
-		LLSD base_contents;
-		base_contents["name"] = base_cat->getName();
-		base_contents["desc"] = "";
-		base_contents["linked_id"] = base_cat->getLinkedUUID();
-		base_contents["type"] = LLAssetType::AT_LINK_FOLDER; 
-		contents.append(base_contents);
-	}
-	if (gSavedSettings.getBOOL("DebugAvatarAppearanceMessage"))
-	{
-		dump_sequential_xml(gAgentAvatarp->getFullname() + "_slam_request", contents);
-	}
-	slam_inventory_folder(getCOF(), contents, link_waiter);
-
-	LL_DEBUGS("Avatar") << self_av_string() << "waiting for LLUpdateAppearanceOnDestroy" << LL_ENDL;
-}
-
-void LLAppearanceMgr::updatePanelOutfitName(const std::string& name)
-{
-	LLSidepanelAppearance* panel_appearance =
-		dynamic_cast<LLSidepanelAppearance *>(LLFloaterSidePanelContainer::getPanel("appearance"));
-	if (panel_appearance)
-	{
-		panel_appearance->refreshCurrentOutfitName(name);
-	}
-}
-
-void LLAppearanceMgr::createBaseOutfitLink(const LLUUID& category, LLPointer<LLInventoryCallback> link_waiter)
-{
-	const LLUUID cof = getCOF();
-	LLViewerInventoryCategory* catp = gInventory.getCategory(category);
-	std::string new_outfit_name = "";
-
-	purgeBaseOutfitLink(cof, link_waiter);
-
-	if (catp && catp->getPreferredType() == LLFolderType::FT_OUTFIT)
-	{
-		link_inventory_object(cof, catp, link_waiter);
-		new_outfit_name = catp->getName();
-	}
-	
-	updatePanelOutfitName(new_outfit_name);
-}
-
-void LLAppearanceMgr::updateAgentWearables(LLWearableHoldingPattern* holder)
-{
-	LL_DEBUGS("Avatar") << "updateAgentWearables()" << LL_ENDL;
-	LLInventoryItem::item_array_t items;
-	std::vector< LLViewerWearable* > wearables;
-	wearables.reserve(32);
-
-	// For each wearable type, find the wearables of that type.
-	for( S32 i = 0; i < LLWearableType::WT_COUNT; i++ )
-	{
-		for (LLWearableHoldingPattern::found_list_t::iterator iter = holder->getFoundList().begin();
-			 iter != holder->getFoundList().end(); ++iter)
-		{
-			LLFoundData& data = *iter;
-			LLViewerWearable* wearable = data.mWearable;
-			if( wearable && ((S32)wearable->getType() == i) )
-			{
-				LLViewerInventoryItem* item = (LLViewerInventoryItem*)gInventory.getItem(data.mItemID);
-				if( item && (item->getAssetUUID() == wearable->getAssetID()) )
-				{
-					items.push_back(item);
-					wearables.push_back(wearable);
-				}
-			}
-		}
-	}
-
-	if(wearables.size() > 0)
-	{
-		gAgentWearables.setWearableOutfit(items, wearables);
-	}
-}
-
-S32 LLAppearanceMgr::countActiveHoldingPatterns()
-{
-	return LLWearableHoldingPattern::countActive();
-}
-
-static void remove_non_link_items(LLInventoryModel::item_array_t &items)
-{
-	LLInventoryModel::item_array_t pruned_items;
-	for (LLInventoryModel::item_array_t::const_iterator iter = items.begin();
-		 iter != items.end();
-		 ++iter)
-	{
- 		const LLViewerInventoryItem *item = (*iter);
-		if (item && item->getIsLinkType())
-		{
-			pruned_items.push_back((*iter));
-		}
-	}
-	items = pruned_items;
-}
-
-//a predicate for sorting inventory items by actual descriptions
-bool sort_by_actual_description(const LLInventoryItem* item1, const LLInventoryItem* item2)
-{
-	if (!item1 || !item2) 
-	{
-		LL_WARNS() << "either item1 or item2 is NULL" << LL_ENDL;
-		return true;
-	}
-
-	return item1->getActualDescription() < item2->getActualDescription();
-}
-
-void item_array_diff(LLInventoryModel::item_array_t& full_list,
-					 LLInventoryModel::item_array_t& keep_list,
-					 LLInventoryModel::item_array_t& kill_list)
-	
-{
-	for (LLInventoryModel::item_array_t::iterator it = full_list.begin();
-		 it != full_list.end();
-		 ++it)
-	{
-		LLViewerInventoryItem *item = *it;
-		if (std::find(keep_list.begin(), keep_list.end(), item) == keep_list.end())
-		{
-			kill_list.push_back(item);
-		}
-	}
-}
-
-S32 LLAppearanceMgr::findExcessOrDuplicateItems(const LLUUID& cat_id,
-												 LLAssetType::EType type,
-												 S32 max_items,
-												 LLInventoryObject::object_list_t& items_to_kill)
-{
-	S32 to_kill_count = 0;
-
-	LLInventoryModel::item_array_t items;
-	getDescendentsOfAssetType(cat_id, items, type);
-	LLInventoryModel::item_array_t curr_items = items;
-	removeDuplicateItems(items);
-	if (max_items > 0)
-	{
-		filterWearableItems(items, max_items);
-	}
-	LLInventoryModel::item_array_t kill_items;
-	item_array_diff(curr_items,items,kill_items);
-	for (LLInventoryModel::item_array_t::iterator it = kill_items.begin();
-		 it != kill_items.end();
-		 ++it)
-	{
-		items_to_kill.push_back(LLPointer<LLInventoryObject>(*it));
-		to_kill_count++;
-	}
-	return to_kill_count;
-}
-	
-
-void LLAppearanceMgr::findAllExcessOrDuplicateItems(const LLUUID& cat_id,
-													LLInventoryObject::object_list_t& items_to_kill)
-{
-	findExcessOrDuplicateItems(cat_id,LLAssetType::AT_BODYPART,
-							   1, items_to_kill);
-	findExcessOrDuplicateItems(cat_id,LLAssetType::AT_CLOTHING,
-							   LLAgentWearables::MAX_CLOTHING_PER_TYPE, items_to_kill);
-	findExcessOrDuplicateItems(cat_id,LLAssetType::AT_OBJECT,
-							   -1, items_to_kill);
-}
-
-void LLAppearanceMgr::enforceCOFItemRestrictions(LLPointer<LLInventoryCallback> cb)
-{
-	LLInventoryObject::object_list_t items_to_kill;
-	findAllExcessOrDuplicateItems(getCOF(), items_to_kill);
-	if (items_to_kill.size()>0)
-	{
-		// Remove duplicate or excess wearables. Should normally be enforced at the UI level, but
-		// this should catch anything that gets through.
-		remove_inventory_items(items_to_kill, cb);
-	}
-}
-
-void LLAppearanceMgr::updateAppearanceFromCOF(bool enforce_item_restrictions,
-											  bool enforce_ordering,
-											  nullary_func_t post_update_func)
-{
-	if (mIsInUpdateAppearanceFromCOF)
-	{
-		LL_WARNS() << "Called updateAppearanceFromCOF inside updateAppearanceFromCOF, skipping" << LL_ENDL;
-		return;
-	}
-
-	LL_DEBUGS("Avatar") << self_av_string() << "starting" << LL_ENDL;
-
-	if (enforce_item_restrictions)
-	{
-		// The point here is just to call
-		// updateAppearanceFromCOF() again after excess items
-		// have been removed. That time we will set
-		// enforce_item_restrictions to false so we don't get
-		// caught in a perpetual loop.
-		LLPointer<LLInventoryCallback> cb(
-			new LLUpdateAppearanceOnDestroy(false, enforce_ordering, post_update_func));
-		enforceCOFItemRestrictions(cb);
-		return;
-	}
-
-	if (enforce_ordering)
-	{
-		//checking integrity of the COF in terms of ordering of wearables, 
-		//checking and updating links' descriptions of wearables in the COF (before analyzed for "dirty" state)
-
-		// As with enforce_item_restrictions handling above, we want
-		// to wait for the update callbacks, then (finally!) call
-		// updateAppearanceFromCOF() with no additional COF munging needed.
-		LLPointer<LLInventoryCallback> cb(
-			new LLUpdateAppearanceOnDestroy(false, false, post_update_func));
-		updateClothingOrderingInfo(LLUUID::null, cb);
-		return;
-	}
-
-	if (!validateClothingOrderingInfo())
-	{
-		LL_WARNS() << "Clothing ordering error" << LL_ENDL;
-	}
-
-	BoolSetter setIsInUpdateAppearanceFromCOF(mIsInUpdateAppearanceFromCOF);
-	selfStartPhase("update_appearance_from_cof");
-
-	// update dirty flag to see if the state of the COF matches
-	// the saved outfit stored as a folder link
-	updateIsDirty();
-
-	// Send server request for appearance update
-	if (gAgent.getRegion() && gAgent.getRegion()->getCentralBakeVersion())
-	{
-		requestServerAppearanceUpdate();
-	}
-
-	LLUUID current_outfit_id = getCOF();
-
-	// Find all the wearables that are in the COF's subtree.
-	LL_DEBUGS() << "LLAppearanceMgr::updateFromCOF()" << LL_ENDL;
-	LLInventoryModel::item_array_t wear_items;
-	LLInventoryModel::item_array_t obj_items;
-	LLInventoryModel::item_array_t gest_items;
-	getUserDescendents(current_outfit_id, wear_items, obj_items, gest_items);
-	// Get rid of non-links in case somehow the COF was corrupted.
-	remove_non_link_items(wear_items);
-	remove_non_link_items(obj_items);
-	remove_non_link_items(gest_items);
-
-	dumpItemArray(wear_items,"asset_dump: wear_item");
-	dumpItemArray(obj_items,"asset_dump: obj_item");
-
-	LLViewerInventoryCategory *cof = gInventory.getCategory(current_outfit_id);
-	if (!gInventory.isCategoryComplete(current_outfit_id))
-	{
-		LL_WARNS() << "COF info is not complete. Version " << cof->getVersion()
-				<< " descendent_count " << cof->getDescendentCount()
-				<< " viewer desc count " << cof->getViewerDescendentCount() << LL_ENDL;
-	}
-	if(!wear_items.size())
-	{
-		LLNotificationsUtil::add("CouldNotPutOnOutfit");
-		return;
-	}
-
-	//preparing the list of wearables in the correct order for LLAgentWearables
-	sortItemsByActualDescription(wear_items);
-
-
-	LL_DEBUGS("Avatar") << "HP block starts" << LL_ENDL;
-	LLTimer hp_block_timer;
-	LLWearableHoldingPattern* holder = new LLWearableHoldingPattern;
-
-	holder->setObjItems(obj_items);
-	holder->setGestItems(gest_items);
-		
-	// Note: can't do normal iteration, because if all the
-	// wearables can be resolved immediately, then the
-	// callback will be called (and this object deleted)
-	// before the final getNextData().
-
-	for(S32 i = 0; i  < wear_items.size(); ++i)
-	{
-		LLViewerInventoryItem *item = wear_items.at(i);
-		LLViewerInventoryItem *linked_item = item ? item->getLinkedItem() : NULL;
-
-		// Fault injection: use debug setting to test asset 
-		// fetch failures (should be replaced by new defaults in
-		// lost&found).
-		U32 skip_type = gSavedSettings.getU32("ForceAssetFail");
-
-		if (item && item->getIsLinkType() && linked_item)
-		{
-			LLFoundData found(linked_item->getUUID(),
-							  linked_item->getAssetUUID(),
-							  linked_item->getName(),
-							  linked_item->getType(),
-							  linked_item->isWearableType() ? linked_item->getWearableType() : LLWearableType::WT_INVALID
-				);
-
-			if (skip_type != LLWearableType::WT_INVALID && skip_type == found.mWearableType)
-			{
-				found.mAssetID.generate(); // Replace with new UUID, guaranteed not to exist in DB
-			}
-			//pushing back, not front, to preserve order of wearables for LLAgentWearables
-			holder->getFoundList().push_back(found);
-		}
-		else
-		{
-			if (!item)
-			{
-				LL_WARNS() << "Attempt to wear a null item " << LL_ENDL;
-			}
-			else if (!linked_item)
-			{
-				LL_WARNS() << "Attempt to wear a broken link [ name:" << item->getName() << " ] " << LL_ENDL;
-			}
-		}
-	}
-
-	selfStartPhase("get_wearables_2");
-
-	for (LLWearableHoldingPattern::found_list_t::iterator it = holder->getFoundList().begin();
-		 it != holder->getFoundList().end(); ++it)
-	{
-		LLFoundData& found = *it;
-
-		LL_DEBUGS() << self_av_string() << "waiting for onWearableAssetFetch callback, asset " << found.mAssetID.asString() << LL_ENDL;
-
-		// Fetch the wearables about to be worn.
-		LLWearableList::instance().getAsset(found.mAssetID,
-											found.mName,
-											gAgentAvatarp,
-											found.mAssetType,
-											onWearableAssetFetch,
-											(void*)holder);
-
-	}
-
-	holder->resetTime(gSavedSettings.getF32("MaxWearableWaitTime"));
-	if (!holder->pollFetchCompletion())
-	{
-		doOnIdleRepeating(boost::bind(&LLWearableHoldingPattern::pollFetchCompletion,holder));
-	}
-	post_update_func();
-
-	LL_DEBUGS("Avatar") << "HP block ends, elapsed " << hp_block_timer.getElapsedTimeF32() << LL_ENDL;
-}
-
-void LLAppearanceMgr::getDescendentsOfAssetType(const LLUUID& category,
-													LLInventoryModel::item_array_t& items,
-													LLAssetType::EType type)
-{
-	LLInventoryModel::cat_array_t cats;
-	LLIsType is_of_type(type);
-	gInventory.collectDescendentsIf(category,
-									cats,
-									items,
-									LLInventoryModel::EXCLUDE_TRASH,
-									is_of_type);
-}
-
-void LLAppearanceMgr::getUserDescendents(const LLUUID& category, 
-											 LLInventoryModel::item_array_t& wear_items,
-											 LLInventoryModel::item_array_t& obj_items,
-											 LLInventoryModel::item_array_t& gest_items)
-{
-	LLInventoryModel::cat_array_t wear_cats;
-	LLFindWearables is_wearable;
-	gInventory.collectDescendentsIf(category,
-									wear_cats,
-									wear_items,
-									LLInventoryModel::EXCLUDE_TRASH,
-									is_wearable);
-
-	LLInventoryModel::cat_array_t obj_cats;
-	LLIsType is_object( LLAssetType::AT_OBJECT );
-	gInventory.collectDescendentsIf(category,
-									obj_cats,
-									obj_items,
-									LLInventoryModel::EXCLUDE_TRASH,
-									is_object);
-
-	// Find all gestures in this folder
-	LLInventoryModel::cat_array_t gest_cats;
-	LLIsType is_gesture( LLAssetType::AT_GESTURE );
-	gInventory.collectDescendentsIf(category,
-									gest_cats,
-									gest_items,
-									LLInventoryModel::EXCLUDE_TRASH,
-									is_gesture);
-}
-
-void LLAppearanceMgr::wearInventoryCategory(LLInventoryCategory* category, bool copy, bool append)
-{
-	if(!category) return;
-
-	selfClearPhases();
-	selfStartPhase("wear_inventory_category");
-
-	gAgentWearables.notifyLoadingStarted();
-
-	LL_INFOS("Avatar") << self_av_string() << "wearInventoryCategory( " << category->getName()
-			 << " )" << LL_ENDL;
-
-	// If we are copying from library, attempt to use AIS to copy the category.
-	bool ais_ran=false;
-	if (copy && AISCommand::isAPIAvailable())
-	{
-		LLUUID parent_id;
-		parent_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_CLOTHING);
-		if (parent_id.isNull())
-		{
-			parent_id = gInventory.getRootFolderID();
-		}
-
-		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)
-	{
-		selfStartPhase("wear_inventory_category_fetch");
-		callAfterCategoryFetch(category->getUUID(),boost::bind(&LLAppearanceMgr::wearCategoryFinal,
-															   &LLAppearanceMgr::instance(),
-															   category->getUUID(), copy, append));
-	}
-}
-
-S32 LLAppearanceMgr::getActiveCopyOperations() const
-{
-	return LLCallAfterInventoryCopyMgr::getInstanceCount(); 
-}
-
-void LLAppearanceMgr::wearCategoryFinal(LLUUID& cat_id, bool copy_items, bool append)
-{
-	LL_INFOS("Avatar") << self_av_string() << "starting" << LL_ENDL;
-
-	selfStopPhase("wear_inventory_category_fetch");
-	
-	// We now have an outfit ready to be copied to agent inventory. Do
-	// it, and wear that outfit normally.
-	LLInventoryCategory* cat = gInventory.getCategory(cat_id);
-	if(copy_items)
-	{
-		LLInventoryModel::cat_array_t* cats;
-		LLInventoryModel::item_array_t* items;
-		gInventory.getDirectDescendentsOf(cat_id, cats, items);
-		std::string name;
-		if(!cat)
-		{
-			// should never happen.
-			name = "New Outfit";
-		}
-		else
-		{
-			name = cat->getName();
-		}
-		LLViewerInventoryItem* item = NULL;
-		LLInventoryModel::item_array_t::const_iterator it = items->begin();
-		LLInventoryModel::item_array_t::const_iterator end = items->end();
-		LLUUID pid;
-		for(; it < end; ++it)
-		{
-			item = *it;
-			if(item)
-			{
-				if(LLInventoryType::IT_GESTURE == item->getInventoryType())
-				{
-					pid = gInventory.findCategoryUUIDForType(LLFolderType::FT_GESTURE);
-				}
-				else
-				{
-					pid = gInventory.findCategoryUUIDForType(LLFolderType::FT_CLOTHING);
-				}
-				break;
-			}
-		}
-		if(pid.isNull())
-		{
-			pid = gInventory.getRootFolderID();
-		}
-		
-		LLUUID new_cat_id = gInventory.createNewCategory(
-			pid,
-			LLFolderType::FT_NONE,
-			name);
-
-		// Create a CopyMgr that will copy items, manage its own destruction
-		new LLCallAfterInventoryCopyMgr(
-			*items, new_cat_id, std::string("wear_inventory_category_callback"),
-			boost::bind(&LLAppearanceMgr::wearInventoryCategoryOnAvatar,
-						LLAppearanceMgr::getInstance(),
-						gInventory.getCategory(new_cat_id),
-						append));
-
-		// BAP fixes a lag in display of created dir.
-		gInventory.notifyObservers();
-	}
-	else
-	{
-		// Wear the inventory category.
-		LLAppearanceMgr::instance().wearInventoryCategoryOnAvatar(cat, append);
-	}
-}
-
-// *NOTE: hack to get from avatar inventory to avatar
-void LLAppearanceMgr::wearInventoryCategoryOnAvatar( LLInventoryCategory* category, bool append )
-{
-	// Avoid unintentionally overwriting old wearables.  We have to do
-	// this up front to avoid having to deal with the case of multiple
-	// wearables being dirty.
-	if (!category) return;
-
-	if ( !LLInventoryCallbackManager::is_instantiated() )
-	{
-		// shutting down, ignore.
-		return;
-	}
-
-	LL_INFOS("Avatar") << self_av_string() << "wearInventoryCategoryOnAvatar '" << category->getName()
-			 << "'" << LL_ENDL;
-			 	
-	if (gAgentCamera.cameraCustomizeAvatar())
-	{
-		// switching to outfit editor should automagically save any currently edited wearable
-		LLFloaterSidePanelContainer::showPanel("appearance", LLSD().with("type", "edit_outfit"));
-	}
-
-	LLAppearanceMgr::changeOutfit(TRUE, category->getUUID(), append);
-}
-
-// FIXME do we really want to search entire inventory for matching name?
-void LLAppearanceMgr::wearOutfitByName(const std::string& name)
-{
-	LL_INFOS("Avatar") << self_av_string() << "Wearing category " << name << LL_ENDL;
-
-	LLInventoryModel::cat_array_t cat_array;
-	LLInventoryModel::item_array_t item_array;
-	LLNameCategoryCollector has_name(name);
-	gInventory.collectDescendentsIf(gInventory.getRootFolderID(),
-									cat_array,
-									item_array,
-									LLInventoryModel::EXCLUDE_TRASH,
-									has_name);
-	bool copy_items = false;
-	LLInventoryCategory* cat = NULL;
-	if (cat_array.size() > 0)
-	{
-		// Just wear the first one that matches
-		cat = cat_array.at(0);
-	}
-	else
-	{
-		gInventory.collectDescendentsIf(LLUUID::null,
-										cat_array,
-										item_array,
-										LLInventoryModel::EXCLUDE_TRASH,
-										has_name);
-		if(cat_array.size() > 0)
-		{
-			cat = cat_array.at(0);
-			copy_items = true;
-		}
-	}
-
-	if(cat)
-	{
-		LLAppearanceMgr::wearInventoryCategory(cat, copy_items, false);
-	}
-	else
-	{
-		LL_WARNS() << "Couldn't find outfit " <<name<< " in wearOutfitByName()"
-				<< LL_ENDL;
-	}
-}
-
-bool areMatchingWearables(const LLViewerInventoryItem *a, const LLViewerInventoryItem *b)
-{
-	return (a->isWearableType() && b->isWearableType() &&
-			(a->getWearableType() == b->getWearableType()));
-}
-
-class LLDeferredCOFLinkObserver: public LLInventoryObserver
-{
-public:
-	LLDeferredCOFLinkObserver(const LLUUID& item_id, LLPointer<LLInventoryCallback> cb, const std::string& description):
-		mItemID(item_id),
-		mCallback(cb),
-		mDescription(description)
-	{
-	}
-
-	~LLDeferredCOFLinkObserver()
-	{
-	}
-	
-	/* virtual */ void changed(U32 mask)
-	{
-		const LLInventoryItem *item = gInventory.getItem(mItemID);
-		if (item)
-		{
-			gInventory.removeObserver(this);
-			LLAppearanceMgr::instance().addCOFItemLink(item, mCallback, mDescription);
-			delete this;
-		}
-	}
-
-private:
-	const LLUUID mItemID;
-	std::string mDescription;
-	LLPointer<LLInventoryCallback> mCallback;
-};
-
-
-// BAP - note that this runs asynchronously if the item is not already loaded from inventory.
-// Dangerous if caller assumes link will exist after calling the function.
-void LLAppearanceMgr::addCOFItemLink(const LLUUID &item_id,
-									 LLPointer<LLInventoryCallback> cb,
-									 const std::string description)
-{
-	const LLInventoryItem *item = gInventory.getItem(item_id);
-	if (!item)
-	{
-		LLDeferredCOFLinkObserver *observer = new LLDeferredCOFLinkObserver(item_id, cb, description);
-		gInventory.addObserver(observer);
-	}
-	else
-	{
-		addCOFItemLink(item, cb, description);
-	}
-}
-
-void LLAppearanceMgr::addCOFItemLink(const LLInventoryItem *item,
-									 LLPointer<LLInventoryCallback> cb,
-									 const std::string description)
-{
-	const LLViewerInventoryItem *vitem = dynamic_cast<const LLViewerInventoryItem*>(item);
-	if (!vitem)
-	{
-		LL_WARNS() << "not an llviewerinventoryitem, failed" << LL_ENDL;
-		return;
-	}
-
-	gInventory.addChangedMask(LLInventoryObserver::LABEL, vitem->getLinkedUUID());
-
-	LLInventoryModel::cat_array_t cat_array;
-	LLInventoryModel::item_array_t item_array;
-	gInventory.collectDescendents(LLAppearanceMgr::getCOF(),
-								  cat_array,
-								  item_array,
-								  LLInventoryModel::EXCLUDE_TRASH);
-	bool linked_already = false;
-	U32 count = 0;
-	for (S32 i=0; i<item_array.size(); i++)
-	{
-		// Are these links to the same object?
-		const LLViewerInventoryItem* inv_item = item_array.at(i).get();
-		const LLWearableType::EType wearable_type = inv_item->getWearableType();
-
-		const bool is_body_part =    (wearable_type == LLWearableType::WT_SHAPE) 
-								  || (wearable_type == LLWearableType::WT_HAIR) 
-								  || (wearable_type == LLWearableType::WT_EYES)
-								  || (wearable_type == LLWearableType::WT_SKIN);
-
-		if (inv_item->getLinkedUUID() == vitem->getLinkedUUID())
-		{
-			linked_already = true;
-		}
-		// Are these links to different items of the same body part
-		// type? If so, new item will replace old.
-		else if ((vitem->isWearableType()) && (vitem->getWearableType() == wearable_type))
-		{
-			++count;
-			if (is_body_part && inv_item->getIsLinkType()  && (vitem->getWearableType() == wearable_type))
-			{
-				remove_inventory_item(inv_item->getUUID(), cb);
-			}
-			else if (count >= LLAgentWearables::MAX_CLOTHING_PER_TYPE)
-			{
-				// MULTI-WEARABLES: make sure we don't go over MAX_CLOTHING_PER_TYPE
-				remove_inventory_item(inv_item->getUUID(), cb);
-			}
-		}
-	}
-
-	if (!linked_already)
-	{
-		LLViewerInventoryItem *copy_item = new LLViewerInventoryItem;
-		copy_item->copyViewerItem(vitem);
-		copy_item->setDescription(description);
-		link_inventory_object(getCOF(), copy_item, cb);
-	}
-}
-
-LLInventoryModel::item_array_t LLAppearanceMgr::findCOFItemLinks(const LLUUID& item_id)
-{
-
-	LLInventoryModel::item_array_t result;
-	const LLViewerInventoryItem *vitem =
-		dynamic_cast<const LLViewerInventoryItem*>(gInventory.getItem(item_id));
-
-	if (vitem)
-	{
-		LLInventoryModel::cat_array_t cat_array;
-		LLInventoryModel::item_array_t item_array;
-		gInventory.collectDescendents(LLAppearanceMgr::getCOF(),
-									  cat_array,
-									  item_array,
-									  LLInventoryModel::EXCLUDE_TRASH);
-		for (S32 i=0; i<item_array.size(); i++)
-		{
-			const LLViewerInventoryItem* inv_item = item_array.at(i).get();
-			if (inv_item->getLinkedUUID() == vitem->getLinkedUUID())
-			{
-				result.push_back(item_array.at(i));
-			}
-		}
-	}
-	return result;
-}
-
-bool LLAppearanceMgr::isLinkedInCOF(const LLUUID& item_id)
-{
-	LLInventoryModel::item_array_t links = LLAppearanceMgr::instance().findCOFItemLinks(item_id);
-	return links.size() > 0;
-}
-
-void LLAppearanceMgr::removeAllClothesFromAvatar()
-{
-	// Fetch worn clothes (i.e. the ones in COF).
-	LLInventoryModel::item_array_t clothing_items;
-	LLInventoryModel::cat_array_t dummy;
-	LLIsType is_clothing(LLAssetType::AT_CLOTHING);
-	gInventory.collectDescendentsIf(getCOF(),
-									dummy,
-									clothing_items,
-									LLInventoryModel::EXCLUDE_TRASH,
-									is_clothing);
-	uuid_vec_t item_ids;
-	for (LLInventoryModel::item_array_t::iterator it = clothing_items.begin();
-		it != clothing_items.end(); ++it)
-	{
-		item_ids.push_back((*it).get()->getLinkedUUID());
-	}
-
-	// Take them off by removing from COF.
-	removeItemsFromAvatar(item_ids);
-}
-
-void LLAppearanceMgr::removeAllAttachmentsFromAvatar()
-{
-	if (!isAgentAvatarValid()) return;
-
-	LLAgentWearables::llvo_vec_t objects_to_remove;
-	
-	for (LLVOAvatar::attachment_map_t::iterator iter = gAgentAvatarp->mAttachmentPoints.begin(); 
-		 iter != gAgentAvatarp->mAttachmentPoints.end();)
-	{
-		LLVOAvatar::attachment_map_t::iterator curiter = iter++;
-		LLViewerJointAttachment* attachment = curiter->second;
-		for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin();
-			 attachment_iter != attachment->mAttachedObjects.end();
-			 ++attachment_iter)
-		{
-			LLViewerObject *attached_object = (*attachment_iter);
-			if (attached_object)
-			{
-				objects_to_remove.push_back(attached_object);
-			}
-		}
-	}
-	uuid_vec_t ids_to_remove;
-	for (LLAgentWearables::llvo_vec_t::iterator it = objects_to_remove.begin();
-		 it != objects_to_remove.end();
-		 ++it)
-	{
-		ids_to_remove.push_back((*it)->getAttachmentItemID());
-	}
-	removeItemsFromAvatar(ids_to_remove);
-}
-
-void LLAppearanceMgr::removeCOFItemLinks(const LLUUID& item_id, LLPointer<LLInventoryCallback> cb)
-{
-	gInventory.addChangedMask(LLInventoryObserver::LABEL, item_id);
-
-	LLInventoryModel::cat_array_t cat_array;
-	LLInventoryModel::item_array_t item_array;
-	gInventory.collectDescendents(LLAppearanceMgr::getCOF(),
-								  cat_array,
-								  item_array,
-								  LLInventoryModel::EXCLUDE_TRASH);
-	for (S32 i=0; i<item_array.size(); i++)
-	{
-		const LLInventoryItem* item = item_array.at(i).get();
-		if (item->getIsLinkType() && item->getLinkedUUID() == item_id)
-		{
-			bool immediate_delete = false;
-			if (item->getType() == LLAssetType::AT_OBJECT)
-			{
-				immediate_delete = true;
-			}
-			remove_inventory_item(item->getUUID(), cb, immediate_delete);
-		}
-	}
-}
-
-void LLAppearanceMgr::removeCOFLinksOfType(LLWearableType::EType type, LLPointer<LLInventoryCallback> cb)
-{
-	LLFindWearablesOfType filter_wearables_of_type(type);
-	LLInventoryModel::cat_array_t cats;
-	LLInventoryModel::item_array_t items;
-	LLInventoryModel::item_array_t::const_iterator it;
-
-	gInventory.collectDescendentsIf(getCOF(), cats, items, true, filter_wearables_of_type);
-	for (it = items.begin(); it != items.end(); ++it)
-	{
-		const LLViewerInventoryItem* item = *it;
-		if (item->getIsLinkType()) // we must operate on links only
-		{
-			remove_inventory_item(item->getUUID(), cb);
-		}
-	}
-}
-
-bool sort_by_linked_uuid(const LLViewerInventoryItem* item1, const LLViewerInventoryItem* item2)
-{
-	if (!item1 || !item2)
-	{
-		LL_WARNS() << "item1, item2 cannot be null, something is very wrong" << LL_ENDL;
-		return true;
-	}
-
-	return item1->getLinkedUUID() < item2->getLinkedUUID();
-}
-
-void LLAppearanceMgr::updateIsDirty()
-{
-	LLUUID cof = getCOF();
-	LLUUID base_outfit;
-
-	// find base outfit link 
-	const LLViewerInventoryItem* base_outfit_item = getBaseOutfitLink();
-	LLViewerInventoryCategory* catp = NULL;
-	if (base_outfit_item && base_outfit_item->getIsLinkType())
-	{
-		catp = base_outfit_item->getLinkedCategory();
-	}
-	if(catp && catp->getPreferredType() == LLFolderType::FT_OUTFIT)
-	{
-		base_outfit = catp->getUUID();
-	}
-
-	// Set dirty to "false" if no base outfit found to disable "Save"
-	// and leave only "Save As" enabled in My Outfits.
-	mOutfitIsDirty = false;
-
-	if (base_outfit.notNull())
-	{
-		LLIsValidItemLink collector;
-
-		LLInventoryModel::cat_array_t cof_cats;
-		LLInventoryModel::item_array_t cof_items;
-		gInventory.collectDescendentsIf(cof, cof_cats, cof_items,
-									  LLInventoryModel::EXCLUDE_TRASH, collector);
-
-		LLInventoryModel::cat_array_t outfit_cats;
-		LLInventoryModel::item_array_t outfit_items;
-		gInventory.collectDescendentsIf(base_outfit, outfit_cats, outfit_items,
-									  LLInventoryModel::EXCLUDE_TRASH, collector);
-
-		if(outfit_items.size() != cof_items.size())
-		{
-			LL_DEBUGS("Avatar") << "item count different - base " << outfit_items.size() << " cof " << cof_items.size() << LL_ENDL;
-			// Current outfit folder should have one more item than the outfit folder.
-			// this one item is the link back to the outfit folder itself.
-			mOutfitIsDirty = true;
-			return;
-		}
-
-		//"dirty" - also means a difference in linked UUIDs and/or a difference in wearables order (links' descriptions)
-		std::sort(cof_items.begin(), cof_items.end(), sort_by_linked_uuid);
-		std::sort(outfit_items.begin(), outfit_items.end(), sort_by_linked_uuid);
-
-		for (U32 i = 0; i < cof_items.size(); ++i)
-		{
-			LLViewerInventoryItem *item1 = cof_items.at(i);
-			LLViewerInventoryItem *item2 = outfit_items.at(i);
-
-			if (item1->getLinkedUUID() != item2->getLinkedUUID() || 
-				item1->getName() != item2->getName() ||
-				item1->getActualDescription() != item2->getActualDescription())
-			{
-				if (item1->getLinkedUUID() != item2->getLinkedUUID())
-				{
-					LL_DEBUGS("Avatar") << "link id different " << LL_ENDL;
-				}
-				else
-				{
-					if (item1->getName() != item2->getName())
-					{
-						LL_DEBUGS("Avatar") << "name different " << item1->getName() << " " << item2->getName() << LL_ENDL;
-					}
-					if (item1->getActualDescription() != item2->getActualDescription())
-					{
-						LL_DEBUGS("Avatar") << "desc different " << item1->getActualDescription()
-											<< " " << item2->getActualDescription() 
-											<< " names " << item1->getName() << " " << item2->getName() << LL_ENDL;
-					}
-				}
-				mOutfitIsDirty = true;
-				return;
-			}
-		}
-	}
-	llassert(!mOutfitIsDirty);
-	LL_DEBUGS("Avatar") << "clean" << LL_ENDL;
-}
-
-// *HACK: Must match name in Library or agent inventory
-const std::string ROOT_GESTURES_FOLDER = "Gestures";
-const std::string COMMON_GESTURES_FOLDER = "Common Gestures";
-const std::string MALE_GESTURES_FOLDER = "Male Gestures";
-const std::string FEMALE_GESTURES_FOLDER = "Female Gestures";
-const std::string SPEECH_GESTURES_FOLDER = "Speech Gestures";
-const std::string OTHER_GESTURES_FOLDER = "Other Gestures";
-
-void LLAppearanceMgr::copyLibraryGestures()
-{
-	LL_INFOS("Avatar") << self_av_string() << "Copying library gestures" << LL_ENDL;
-
-	// Copy gestures
-	LLUUID lib_gesture_cat_id =
-		gInventory.findLibraryCategoryUUIDForType(LLFolderType::FT_GESTURE,false);
-	if (lib_gesture_cat_id.isNull())
-	{
-		LL_WARNS() << "Unable to copy gestures, source category not found" << LL_ENDL;
-	}
-	LLUUID dst_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_GESTURE);
-
-	std::vector<std::string> gesture_folders_to_copy;
-	gesture_folders_to_copy.push_back(MALE_GESTURES_FOLDER);
-	gesture_folders_to_copy.push_back(FEMALE_GESTURES_FOLDER);
-	gesture_folders_to_copy.push_back(COMMON_GESTURES_FOLDER);
-	gesture_folders_to_copy.push_back(SPEECH_GESTURES_FOLDER);
-	gesture_folders_to_copy.push_back(OTHER_GESTURES_FOLDER);
-
-	for(std::vector<std::string>::iterator it = gesture_folders_to_copy.begin();
-		it != gesture_folders_to_copy.end();
-		++it)
-	{
-		std::string& folder_name = *it;
-
-		LLPointer<LLInventoryCallback> cb(NULL);
-
-		// After copying gestures, activate Common, Other, plus
-		// Male and/or Female, depending upon the initial outfit gender.
-		ESex gender = gAgentAvatarp->getSex();
-
-		std::string activate_male_gestures;
-		std::string activate_female_gestures;
-		switch (gender) {
-			case SEX_MALE:
-				activate_male_gestures = MALE_GESTURES_FOLDER;
-				break;
-			case SEX_FEMALE:
-				activate_female_gestures = FEMALE_GESTURES_FOLDER;
-				break;
-			case SEX_BOTH:
-				activate_male_gestures = MALE_GESTURES_FOLDER;
-				activate_female_gestures = FEMALE_GESTURES_FOLDER;
-				break;
-		}
-
-		if (folder_name == activate_male_gestures ||
-			folder_name == activate_female_gestures ||
-			folder_name == COMMON_GESTURES_FOLDER ||
-			folder_name == OTHER_GESTURES_FOLDER)
-		{
-			cb = new LLBoostFuncInventoryCallback(activate_gesture_cb);
-		}
-
-		LLUUID cat_id = findDescendentCategoryIDByName(lib_gesture_cat_id,folder_name);
-		if (cat_id.isNull())
-		{
-			LL_WARNS() << self_av_string() << "failed to find gesture folder for " << folder_name << LL_ENDL;
-		}
-		else
-		{
-			LL_DEBUGS("Avatar") << self_av_string() << "initiating fetch and copy for " << folder_name << " cat_id " << cat_id << LL_ENDL;
-			callAfterCategoryFetch(cat_id,
-								   boost::bind(&LLAppearanceMgr::shallowCopyCategory,
-											   &LLAppearanceMgr::instance(),
-											   cat_id, dst_id, cb));
-		}
-	}
-}
-
-// Handler for anything that's deferred until avatar de-clouds.
-void LLAppearanceMgr::onFirstFullyVisible()
-{
-	gAgentAvatarp->outputRezTiming("Avatar fully loaded");
-	gAgentAvatarp->reportAvatarRezTime();
-	gAgentAvatarp->debugAvatarVisible();
-
-	// If this is the first time we've ever logged in,
-	// then copy default gestures from the library.
-	if (gAgent.isFirstLogin()) {
-		copyLibraryGestures();
-	}
-}
-
-// update "dirty" state - defined outside class to allow for calling
-// after appearance mgr instance has been destroyed.
-void appearance_mgr_update_dirty_state()
-{
-	if (LLAppearanceMgr::instanceExists())
-	{
-		LLAppearanceMgr::getInstance()->updateIsDirty();
-		LLAppearanceMgr::getInstance()->setOutfitLocked(false);
-		gAgentWearables.notifyLoadingFinished();
-	}
-}
-
-void update_base_outfit_after_ordering()
-{
-	LLAppearanceMgr& app_mgr = LLAppearanceMgr::instance();
-	
-	LLPointer<LLInventoryCallback> dirty_state_updater =
-		new LLBoostFuncInventoryCallback(no_op_inventory_func, appearance_mgr_update_dirty_state);
-
-	//COF contains only links so we copy to the Base Outfit only links
-	const LLUUID base_outfit_id = app_mgr.getBaseOutfitUUID();
-	bool copy_folder_links = false;
-	app_mgr.slamCategoryLinks(app_mgr.getCOF(), base_outfit_id, copy_folder_links, dirty_state_updater);
-
-}
-
-// Save COF changes - update the contents of the current base outfit
-// to match the current COF. Fails if no current base outfit is set.
-bool LLAppearanceMgr::updateBaseOutfit()
-{
-	if (isOutfitLocked())
-	{
-		// don't allow modify locked outfit
-		llassert(!isOutfitLocked());
-		return false;
-	}
-
-	setOutfitLocked(true);
-
-	gAgentWearables.notifyLoadingStarted();
-
-	const LLUUID base_outfit_id = getBaseOutfitUUID();
-	if (base_outfit_id.isNull()) return false;
-	LL_DEBUGS("Avatar") << "saving cof to base outfit " << base_outfit_id << LL_ENDL;
-
-	LLPointer<LLInventoryCallback> cb =
-		new LLBoostFuncInventoryCallback(no_op_inventory_func, update_base_outfit_after_ordering);
-	// Really shouldn't be needed unless there's a race condition -
-	// updateAppearanceFromCOF() already calls updateClothingOrderingInfo.
-	updateClothingOrderingInfo(LLUUID::null, cb);
-
-	return true;
-}
-
-void LLAppearanceMgr::divvyWearablesByType(const LLInventoryModel::item_array_t& items, wearables_by_type_t& items_by_type)
-{
-	items_by_type.resize(LLWearableType::WT_COUNT);
-	if (items.empty()) return;
-
-	for (S32 i=0; i<items.size(); i++)
-	{
-		LLViewerInventoryItem *item = items.at(i);
-		if (!item)
-		{
-			LL_WARNS("Appearance") << "NULL item found" << LL_ENDL;
-			continue;
-		}
-		// Ignore non-wearables.
-		if (!item->isWearableType())
-			continue;
-		LLWearableType::EType type = item->getWearableType();
-		if(type < 0 || type >= LLWearableType::WT_COUNT)
-		{
-			LL_WARNS("Appearance") << "Invalid wearable type. Inventory type does not match wearable flag bitfield." << LL_ENDL;
-			continue;
-		}
-		items_by_type[type].push_back(item);
-	}
-}
-
-std::string build_order_string(LLWearableType::EType type, U32 i)
-{
-		std::ostringstream order_num;
-		order_num << ORDER_NUMBER_SEPARATOR << type * 100 + i;
-		return order_num.str();
-}
-
-struct WearablesOrderComparator
-{
-	LOG_CLASS(WearablesOrderComparator);
-	WearablesOrderComparator(const LLWearableType::EType type)
-	{
-		mControlSize = build_order_string(type, 0).size();
-	};
-
-	bool operator()(const LLInventoryItem* item1, const LLInventoryItem* item2)
-	{
-		const std::string& desc1 = item1->getActualDescription();
-		const std::string& desc2 = item2->getActualDescription();
-		
-		bool item1_valid = (desc1.size() == mControlSize) && (ORDER_NUMBER_SEPARATOR == desc1[0]);
-		bool item2_valid = (desc2.size() == mControlSize) && (ORDER_NUMBER_SEPARATOR == desc2[0]);
-
-		if (item1_valid && item2_valid)
-			return desc1 < desc2;
-
-		//we need to sink down invalid items: items with empty descriptions, items with "Broken link" descriptions,
-		//items with ordering information but not for the associated wearables type
-		if (!item1_valid && item2_valid) 
-			return false;
-		else if (item1_valid && !item2_valid)
-			return true;
-
-		return item1->getName() < item2->getName();
-	}
-
-	U32 mControlSize;
-};
-
-void LLAppearanceMgr::getWearableOrderingDescUpdates(LLInventoryModel::item_array_t& wear_items,
-													 desc_map_t& desc_map)
-{
-	wearables_by_type_t items_by_type(LLWearableType::WT_COUNT);
-	divvyWearablesByType(wear_items, items_by_type);
-
-	for (U32 type = LLWearableType::WT_SHIRT; type < LLWearableType::WT_COUNT; type++)
-	{
-		U32 size = items_by_type[type].size();
-		if (!size) continue;
-		
-		//sinking down invalid items which need reordering
-		std::sort(items_by_type[type].begin(), items_by_type[type].end(), WearablesOrderComparator((LLWearableType::EType) type));
-		
-		//requesting updates only for those links which don't have "valid" descriptions
-		for (U32 i = 0; i < size; i++)
-		{
-			LLViewerInventoryItem* item = items_by_type[type][i];
-			if (!item) continue;
-			
-			std::string new_order_str = build_order_string((LLWearableType::EType)type, i);
-			if (new_order_str == item->getActualDescription()) continue;
-			
-			desc_map[item->getUUID()] = new_order_str;
-		}
-	}
-}
-
-bool LLAppearanceMgr::validateClothingOrderingInfo(LLUUID cat_id)
-{
-	// COF is processed if cat_id is not specified
-	if (cat_id.isNull())
-	{
-		cat_id = getCOF();
-	}
-
-	LLInventoryModel::item_array_t wear_items;
-	getDescendentsOfAssetType(cat_id, wear_items, LLAssetType::AT_CLOTHING);
-
-	// Identify items for which desc needs to change.
-	desc_map_t desc_map;
-	getWearableOrderingDescUpdates(wear_items, desc_map);
-
-	for (desc_map_t::const_iterator it = desc_map.begin();
-		 it != desc_map.end(); ++it)
-	{
-		const LLUUID& item_id = it->first;
-		const std::string& new_order_str = it->second;
-		LLViewerInventoryItem *item = gInventory.getItem(item_id);
-		LL_WARNS() << "Order validation fails: " << item->getName()
-				<< " needs to update desc to: " << new_order_str
-				<< " (from: " << item->getActualDescription() << ")" << LL_ENDL;
-	}
-	
-	return desc_map.size() == 0;
-}
-
-void LLAppearanceMgr::updateClothingOrderingInfo(LLUUID cat_id,
-												 LLPointer<LLInventoryCallback> cb)
-{
-	// COF is processed if cat_id is not specified
-	if (cat_id.isNull())
-	{
-		cat_id = getCOF();
-	}
-
-	LLInventoryModel::item_array_t wear_items;
-	getDescendentsOfAssetType(cat_id, wear_items, LLAssetType::AT_CLOTHING);
-
-	// Identify items for which desc needs to change.
-	desc_map_t desc_map;
-	getWearableOrderingDescUpdates(wear_items, desc_map);
-
-	for (desc_map_t::const_iterator it = desc_map.begin();
-		 it != desc_map.end(); ++it)
-	{
-		LLSD updates;
-		const LLUUID& item_id = it->first;
-		const std::string& new_order_str = it->second;
-		LLViewerInventoryItem *item = gInventory.getItem(item_id);
-		LL_DEBUGS("Avatar") << item->getName() << " updating desc to: " << new_order_str
-			<< " (was: " << item->getActualDescription() << ")" << LL_ENDL;
-		updates["desc"] = new_order_str;
-		update_inventory_item(item_id,updates,cb);
-	}
-		
-}
-
-#if 1
-class RequestAgentUpdateAppearanceResponder: public LLHTTPClient::Responder
-{
-	LOG_CLASS(RequestAgentUpdateAppearanceResponder);
-
-	friend class LLAppearanceMgr;
-	
-public:
-	RequestAgentUpdateAppearanceResponder();
-
-	virtual ~RequestAgentUpdateAppearanceResponder();
-
-private:
-	// Called when sendServerAppearanceUpdate called. May or may not
-	// trigger a request depending on various bits of state.
-	void onRequestRequested();
-
-	// Post the actual appearance request to cap.
-	void sendRequest();
-
-	void debugCOF(const LLSD& content);
-
-protected:
-	// Successful completion.
-	/* virtual */ void httpSuccess();
-
-	// Error
-	/*virtual*/ void httpFailure();
-
-	void onFailure();
-	void onSuccess();
-
-	S32 mInFlightCounter;
-	LLTimer mInFlightTimer;
-	LLPointer<LLHTTPRetryPolicy> mRetryPolicy;
-};
-
-RequestAgentUpdateAppearanceResponder::RequestAgentUpdateAppearanceResponder()
-{
-	bool retry_on_4xx = true;
-	mRetryPolicy = new LLAdaptiveRetryPolicy(1.0, 32.0, 2.0, 10, retry_on_4xx);
-	mInFlightCounter = 0;
-}
-
-RequestAgentUpdateAppearanceResponder::~RequestAgentUpdateAppearanceResponder()
-{
-}
-
-void RequestAgentUpdateAppearanceResponder::onRequestRequested()
-{
-	// If we have already received an update for this or higher cof version, ignore.
-	S32 cof_version = LLAppearanceMgr::instance().getCOFVersion();
-	S32 last_rcv = gAgentAvatarp->mLastUpdateReceivedCOFVersion;
-	S32 last_req = gAgentAvatarp->mLastUpdateRequestCOFVersion;
-	LL_DEBUGS("Avatar") << "cof_version " << cof_version
-						<< " last_rcv " << last_rcv
-						<< " last_req " << last_req
-						<< " in flight " << mInFlightCounter << LL_ENDL;
-	if ((mInFlightCounter>0) && (mInFlightTimer.hasExpired()))
-	{
-		LL_WARNS("Avatar") << "in flight timer expired, resetting " << LL_ENDL;
-		mInFlightCounter = 0;
-	}
-	if (cof_version < last_rcv)
-	{
-		LL_DEBUGS("Avatar") << "Have already received update for cof version " << last_rcv
-							<< " will not request for " << cof_version << LL_ENDL;
-		return;
-	}
-	if (mInFlightCounter>0 && last_req >= cof_version)
-	{
-		LL_DEBUGS("Avatar") << "Request already in flight for cof version " << last_req 
-							<< " will not request for " << cof_version << LL_ENDL;
-		return;
-	}
-
-	// Actually send the request.
-	LL_DEBUGS("Avatar") << "Will send request for cof_version " << cof_version << LL_ENDL;
-	mRetryPolicy->reset();
-	sendRequest();
-}
-	
-void RequestAgentUpdateAppearanceResponder::sendRequest()
-{
-	if (gAgentAvatarp->isEditingAppearance()) 
-	{
-		// don't send out appearance updates if in appearance editing mode
-		return;
-	}
-
-	if (!gAgent.getRegion())
-	{
-		LL_WARNS() << "Region not set, cannot request server appearance update" << LL_ENDL;
-		return;
-	}
-	if (gAgent.getRegion()->getCentralBakeVersion()==0)
-	{
-		LL_WARNS() << "Region does not support baking" << LL_ENDL;
-	}
-	std::string url = gAgent.getRegion()->getCapability("UpdateAvatarAppearance");	
-	if (url.empty())
-	{
-		LL_WARNS() << "No cap for UpdateAvatarAppearance." << LL_ENDL;
-		return;
-	}
-	
-	LLSD body;
-	S32 cof_version = LLAppearanceMgr::instance().getCOFVersion();
-	if (gSavedSettings.getBOOL("DebugAvatarExperimentalServerAppearanceUpdate"))
-	{
-		body = LLAppearanceMgr::instance().dumpCOF();
-	}
-	else
-	{
-		body["cof_version"] = cof_version;
-		if (gSavedSettings.getBOOL("DebugForceAppearanceRequestFailure"))
-		{
-			body["cof_version"] = cof_version+999;
-		}
-	}
-	LL_DEBUGS("Avatar") << "request url " << url << " my_cof_version " << cof_version << LL_ENDL;
-
-	mInFlightCounter++;
-	mInFlightTimer.setTimerExpirySec(60.0);
-	LLHTTPClient::post(url, body, this);
-	llassert(cof_version >= gAgentAvatarp->mLastUpdateRequestCOFVersion);
-	gAgentAvatarp->mLastUpdateRequestCOFVersion = cof_version;
-}
-
-void RequestAgentUpdateAppearanceResponder::debugCOF(const LLSD& content)
-{
-	LL_INFOS("Avatar") << "AIS COF, version received: " << content["expected"].asInteger()
-					   << " ================================= " << LL_ENDL;
-	std::set<LLUUID> ais_items, local_items;
-	const LLSD& cof_raw = content["cof_raw"];
-	for (LLSD::array_const_iterator it = cof_raw.beginArray();
-		 it != cof_raw.endArray(); ++it)
-	{
-		const LLSD& item = *it;
-		if (item["parent_id"].asUUID() == LLAppearanceMgr::instance().getCOF())
-		{
-			ais_items.insert(item["item_id"].asUUID());
-			if (item["type"].asInteger() == 24) // link
-			{
-				LL_INFOS("Avatar") << "AIS Link: item_id: " << item["item_id"].asUUID()
-								   << " linked_item_id: " << item["asset_id"].asUUID()
-								   << " name: " << item["name"].asString()
-								   << LL_ENDL; 
-			}
-			else if (item["type"].asInteger() == 25) // folder link
-			{
-				LL_INFOS("Avatar") << "AIS Folder link: item_id: " << item["item_id"].asUUID()
-								   << " linked_item_id: " << item["asset_id"].asUUID()
-								   << " name: " << item["name"].asString()
-								   << LL_ENDL; 
-			}
-			else
-			{
-				LL_INFOS("Avatar") << "AIS Other: item_id: " << item["item_id"].asUUID()
-								   << " linked_item_id: " << item["asset_id"].asUUID()
-								   << " name: " << item["name"].asString()
-								   << " type: " << item["type"].asInteger()
-								   << LL_ENDL; 
-			}
-		}
-	}
-	LL_INFOS("Avatar") << LL_ENDL;
-	LL_INFOS("Avatar") << "Local COF, version requested: " << content["observed"].asInteger() 
-					   << " ================================= " << LL_ENDL;
-	LLInventoryModel::cat_array_t cat_array;
-	LLInventoryModel::item_array_t item_array;
-	gInventory.collectDescendents(LLAppearanceMgr::instance().getCOF(),
-								  cat_array,item_array,LLInventoryModel::EXCLUDE_TRASH);
-	for (S32 i=0; i<item_array.size(); i++)
-	{
-		const LLViewerInventoryItem* inv_item = item_array.at(i).get();
-		local_items.insert(inv_item->getUUID());
-		LL_INFOS("Avatar") << "LOCAL: item_id: " << inv_item->getUUID()
-						   << " linked_item_id: " << inv_item->getLinkedUUID()
-						   << " name: " << inv_item->getName()
-						   << " parent: " << inv_item->getParentUUID()
-						   << LL_ENDL;
-	}
-	LL_INFOS("Avatar") << " ================================= " << LL_ENDL;
-	S32 local_only = 0, ais_only = 0;
-	for (std::set<LLUUID>::iterator it = local_items.begin(); it != local_items.end(); ++it)
-	{
-		if (ais_items.find(*it) == ais_items.end())
-		{
-			LL_INFOS("Avatar") << "LOCAL ONLY: " << *it << LL_ENDL;
-			local_only++;
-		}
-	}
-	for (std::set<LLUUID>::iterator it = ais_items.begin(); it != ais_items.end(); ++it)
-	{
-		if (local_items.find(*it) == local_items.end())
-		{
-			LL_INFOS("Avatar") << "AIS ONLY: " << *it << LL_ENDL;
-			ais_only++;
-		}
-	}
-	if (local_only==0 && ais_only==0)
-	{
-		LL_INFOS("Avatar") << "COF contents identical, only version numbers differ (req "
-						   << content["observed"].asInteger()
-						   << " rcv " << content["expected"].asInteger()
-						   << ")" << LL_ENDL;
-	}
-}
-
-/* virtual */ void RequestAgentUpdateAppearanceResponder::httpSuccess()
-{
-	const LLSD& content = getContent();
-	if (!content.isMap())
-	{
-		failureResult(HTTP_INTERNAL_ERROR, "Malformed response contents", content);
-		return;
-	}
-	if (content["success"].asBoolean())
-	{
-		LL_DEBUGS("Avatar") << "succeeded" << LL_ENDL;
-		if (gSavedSettings.getBOOL("DebugAvatarAppearanceMessage"))
-		{
-			dump_sequential_xml(gAgentAvatarp->getFullname() + "_appearance_request_ok", content);
-		}
-
-		onSuccess();
-	}
-	else
-	{
-		failureResult(HTTP_INTERNAL_ERROR, "Non-success response", content);
-	}
-}
-
-void RequestAgentUpdateAppearanceResponder::onSuccess()
-{
-	mInFlightCounter = llmax(mInFlightCounter-1,0);
-}
-
-/*virtual*/ void RequestAgentUpdateAppearanceResponder::httpFailure()
-{
-	LL_WARNS("Avatar") << "appearance update request failed, status "
-					   << getStatus() << " reason " << getReason() << LL_ENDL;
-
-	if (gSavedSettings.getBOOL("DebugAvatarAppearanceMessage"))
-	{
-		const LLSD& content = getContent();
-		dump_sequential_xml(gAgentAvatarp->getFullname() + "_appearance_request_error", content);
-		debugCOF(content);
-	}
-	onFailure();
-}
-
-void RequestAgentUpdateAppearanceResponder::onFailure()
-{
-	mInFlightCounter = llmax(mInFlightCounter-1,0);
-
-	F32 seconds_to_wait;
-	mRetryPolicy->onFailure(getStatus(), getResponseHeaders());
-	if (mRetryPolicy->shouldRetry(seconds_to_wait))
-	{
-		LL_INFOS() << "retrying" << LL_ENDL;
-		doAfterInterval(boost::bind(&RequestAgentUpdateAppearanceResponder::sendRequest,this),
-						seconds_to_wait);
-	}
-	else
-	{
-		LL_WARNS() << "giving up after too many retries" << LL_ENDL;
-	}
-}	
-#else
-
-
-#endif
-
-
-LLSD LLAppearanceMgr::dumpCOF() const
-{
-	LLSD links = LLSD::emptyArray();
-	LLMD5 md5;
-	
-	LLInventoryModel::cat_array_t cat_array;
-	LLInventoryModel::item_array_t item_array;
-	gInventory.collectDescendents(getCOF(),cat_array,item_array,LLInventoryModel::EXCLUDE_TRASH);
-	for (S32 i=0; i<item_array.size(); i++)
-	{
-		const LLViewerInventoryItem* inv_item = item_array.at(i).get();
-		LLSD item;
-		LLUUID item_id(inv_item->getUUID());
-		md5.update((unsigned char*)item_id.mData, 16);
-		item["description"] = inv_item->getActualDescription();
-		md5.update(inv_item->getActualDescription());
-		item["asset_type"] = inv_item->getActualType();
-		LLUUID linked_id(inv_item->getLinkedUUID());
-		item["linked_id"] = linked_id;
-		md5.update((unsigned char*)linked_id.mData, 16);
-
-		if (LLAssetType::AT_LINK == inv_item->getActualType())
-		{
-			const LLViewerInventoryItem* linked_item = inv_item->getLinkedItem();
-			if (NULL == linked_item)
-			{
-				LL_WARNS() << "Broken link for item '" << inv_item->getName()
-						<< "' (" << inv_item->getUUID()
-						<< ") during requestServerAppearanceUpdate" << LL_ENDL;
-				continue;
-			}
-			// Some assets may be 'hidden' and show up as null in the viewer.
-			//if (linked_item->getAssetUUID().isNull())
-			//{
-			//	LL_WARNS() << "Broken link (null asset) for item '" << inv_item->getName()
-			//			<< "' (" << inv_item->getUUID()
-			//			<< ") during requestServerAppearanceUpdate" << LL_ENDL;
-			//	continue;
-			//}
-			LLUUID linked_asset_id(linked_item->getAssetUUID());
-			md5.update((unsigned char*)linked_asset_id.mData, 16);
-			U32 flags = linked_item->getFlags();
-			md5.update(boost::lexical_cast<std::string>(flags));
-		}
-		else if (LLAssetType::AT_LINK_FOLDER != inv_item->getActualType())
-		{
-			LL_WARNS() << "Non-link item '" << inv_item->getName()
-					<< "' (" << inv_item->getUUID()
-					<< ") type " << (S32) inv_item->getActualType()
-					<< " during requestServerAppearanceUpdate" << LL_ENDL;
-			continue;
-		}
-		links.append(item);
-	}
-	LLSD result = LLSD::emptyMap();
-	result["cof_contents"] = links;
-	char cof_md5sum[MD5HEX_STR_SIZE];
-	md5.finalize();
-	md5.hex_digest(cof_md5sum);
-	result["cof_md5sum"] = std::string(cof_md5sum);
-	return result;
-}
-
-void LLAppearanceMgr::requestServerAppearanceUpdate()
-{
-	mAppearanceResponder->onRequestRequested();
-}
-
-class LLIncrementCofVersionResponder : public LLHTTPClient::Responder
-{
-	LOG_CLASS(LLIncrementCofVersionResponder);
-public:
-	LLIncrementCofVersionResponder() : LLHTTPClient::Responder()
-	{
-		mRetryPolicy = new LLAdaptiveRetryPolicy(1.0, 16.0, 2.0, 5);
-	}
-
-	virtual ~LLIncrementCofVersionResponder()
-	{
-	}
-
-protected:
-	virtual void httpSuccess()
-	{
-		LL_INFOS() << "Successfully incremented agent's COF." << LL_ENDL;
-		const LLSD& content = getContent();
-		if (!content.isMap())
-		{
-			failureResult(HTTP_INTERNAL_ERROR, "Malformed response contents", content);
-			return;
-		}
-		S32 new_version = content["category"]["version"].asInteger();
-
-		// cof_version should have increased
-		llassert(new_version > gAgentAvatarp->mLastUpdateRequestCOFVersion);
-
-		gAgentAvatarp->mLastUpdateRequestCOFVersion = new_version;
-	}
-
-	virtual void httpFailure()
-	{
-		LL_WARNS("Avatar") << "While attempting to increment the agent's cof we got an error "
-						   << dumpResponse() << LL_ENDL;
-		F32 seconds_to_wait;
-		mRetryPolicy->onFailure(getStatus(), getResponseHeaders());
-		if (mRetryPolicy->shouldRetry(seconds_to_wait))
-		{
-			LL_INFOS() << "retrying" << LL_ENDL;
-			doAfterInterval(boost::bind(&LLAppearanceMgr::incrementCofVersion,
-										LLAppearanceMgr::getInstance(),
-										LLHTTPClient::ResponderPtr(this)),
-										seconds_to_wait);
-		}
-		else
-		{
-			LL_WARNS() << "giving up after too many retries" << LL_ENDL;
-		}
-	}
-
-private:
-	LLPointer<LLHTTPRetryPolicy> mRetryPolicy;
-};
-
-void LLAppearanceMgr::incrementCofVersion(LLHTTPClient::ResponderPtr responder_ptr)
-{
-	// If we don't have a region, report it as an error
-	if (gAgent.getRegion() == NULL)
-	{
-		LL_WARNS() << "Region not set, cannot request cof_version increment" << LL_ENDL;
-		return;
-	}
-
-	std::string url = gAgent.getRegion()->getCapability("IncrementCofVersion");
-	if (url.empty())
-	{
-		LL_WARNS() << "No cap for IncrementCofVersion." << LL_ENDL;
-		return;
-	}
-
-	LL_INFOS() << "Requesting cof_version be incremented via capability to: "
-			<< url << LL_ENDL;
-	LLSD headers;
-	LLSD body = LLSD::emptyMap();
-
-	if (!responder_ptr.get())
-	{
-		responder_ptr = LLHTTPClient::ResponderPtr(new LLIncrementCofVersionResponder());
-	}
-
-	LLHTTPClient::get(url, body, responder_ptr, headers, 30.0f);
-}
-
-U32 LLAppearanceMgr::getNumAttachmentsInCOF()
-{
-	const LLUUID cof = getCOF();
-	LLInventoryModel::item_array_t obj_items;
-	getDescendentsOfAssetType(cof, obj_items, LLAssetType::AT_OBJECT);
-	return obj_items.size();
-}
-
-
-std::string LLAppearanceMgr::getAppearanceServiceURL() const
-{
-	if (gSavedSettings.getString("DebugAvatarAppearanceServiceURLOverride").empty())
-	{
-		return mAppearanceServiceURL;
-	}
-	return gSavedSettings.getString("DebugAvatarAppearanceServiceURLOverride");
-}
-
-void show_created_outfit(LLUUID& folder_id, bool show_panel = true)
-{
-	if (!LLApp::isRunning())
-	{
-		LL_WARNS() << "called during shutdown, skipping" << LL_ENDL;
-		return;
-	}
-	
-	LL_DEBUGS("Avatar") << "called" << LL_ENDL;
-	LLSD key;
-	
-	//EXT-7727. For new accounts inventory callback is created during login process
-	// and may be processed after login process is finished
-	if (show_panel)
-	{
-		LL_DEBUGS("Avatar") << "showing panel" << LL_ENDL;
-		LLFloaterSidePanelContainer::showPanel("appearance", "panel_outfits_inventory", key);
-		
-	}
-	LLOutfitsList *outfits_list =
-		dynamic_cast<LLOutfitsList*>(LLFloaterSidePanelContainer::getPanel("appearance", "outfitslist_tab"));
-	if (outfits_list)
-	{
-		outfits_list->setSelectedOutfitByUUID(folder_id);
-	}
-	
-	LLAppearanceMgr::getInstance()->updateIsDirty();
-	gAgentWearables.notifyLoadingFinished(); // New outfit is saved.
-	LLAppearanceMgr::getInstance()->updatePanelOutfitName("");
-
-	// For SSB, need to update appearance after we add a base outfit
-	// link, since, the COF version has changed. There is a race
-	// condition in initial outfit setup which can lead to rez
-	// failures - SH-3860.
-	LL_DEBUGS("Avatar") << "requesting appearance update after createBaseOutfitLink" << LL_ENDL;
-	LLPointer<LLInventoryCallback> cb = new LLUpdateAppearanceOnDestroy;
-	LLAppearanceMgr::getInstance()->createBaseOutfitLink(folder_id, cb);
-}
-
-void LLAppearanceMgr::onOutfitFolderCreated(const LLUUID& folder_id, bool show_panel)
-{
-	LLPointer<LLInventoryCallback> cb =
-		new LLBoostFuncInventoryCallback(no_op_inventory_func,
-										 boost::bind(&LLAppearanceMgr::onOutfitFolderCreatedAndClothingOrdered,this,folder_id,show_panel));
-	updateClothingOrderingInfo(LLUUID::null, cb);
-}
-
-void LLAppearanceMgr::onOutfitFolderCreatedAndClothingOrdered(const LLUUID& folder_id, bool show_panel)
-{
-	LLPointer<LLInventoryCallback> cb =
-		new LLBoostFuncInventoryCallback(no_op_inventory_func,
-										 boost::bind(show_created_outfit,folder_id,show_panel));
-	bool copy_folder_links = false;
-	slamCategoryLinks(getCOF(), folder_id, copy_folder_links, cb);
-}
-
-void LLAppearanceMgr::makeNewOutfitLinks(const std::string& new_folder_name, bool show_panel)
-{
-	if (!isAgentAvatarValid()) return;
-
-	LL_DEBUGS("Avatar") << "creating new outfit" << LL_ENDL;
-
-	gAgentWearables.notifyLoadingStarted();
-
-	// First, make a folder in the My Outfits directory.
-	const LLUUID parent_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_MY_OUTFITS);
-	if (AISCommand::isAPIAvailable())
-	{
-		// cap-based category creation was buggy until recently. use
-		// existence of AIS as an indicator the fix is present. Does
-		// not actually use AIS to create the category.
-		inventory_func_type func = boost::bind(&LLAppearanceMgr::onOutfitFolderCreated,this,_1,show_panel);
-		LLUUID folder_id = gInventory.createNewCategory(
-			parent_id,
-			LLFolderType::FT_OUTFIT,
-			new_folder_name,
-			func);
-	}
-	else
-	{		
-		LLUUID folder_id = gInventory.createNewCategory(
-			parent_id,
-			LLFolderType::FT_OUTFIT,
-			new_folder_name);
-		onOutfitFolderCreated(folder_id, show_panel);
-	}
-}
-
-void LLAppearanceMgr::wearBaseOutfit()
-{
-	const LLUUID& base_outfit_id = getBaseOutfitUUID();
-	if (base_outfit_id.isNull()) return;
-	
-	updateCOF(base_outfit_id);
-}
-
-void LLAppearanceMgr::removeItemsFromAvatar(const uuid_vec_t& ids_to_remove)
-{
-	if (ids_to_remove.empty())
-	{
-		LL_WARNS() << "called with empty list, nothing to do" << LL_ENDL;
-		return;
-	}
-	LLPointer<LLInventoryCallback> cb = new LLUpdateAppearanceOnDestroy;
-	for (uuid_vec_t::const_iterator it = ids_to_remove.begin(); it != ids_to_remove.end(); ++it)
-	{
-		const LLUUID& id_to_remove = *it;
-		const LLUUID& linked_item_id = gInventory.getLinkedItemID(id_to_remove);
-		removeCOFItemLinks(linked_item_id, cb);
-		addDoomedTempAttachment(linked_item_id);
-	}
-}
-
-void LLAppearanceMgr::removeItemFromAvatar(const LLUUID& id_to_remove)
-{
-	LLUUID linked_item_id = gInventory.getLinkedItemID(id_to_remove);
-	LLPointer<LLInventoryCallback> cb = new LLUpdateAppearanceOnDestroy;
-	removeCOFItemLinks(linked_item_id, cb);
-	addDoomedTempAttachment(linked_item_id);
-}
-
-
-// Adds the given item ID to mDoomedTempAttachmentIDs iff it's a temp attachment
-void LLAppearanceMgr::addDoomedTempAttachment(const LLUUID& id_to_remove)
-{
-	LLViewerObject * attachmentp = gAgentAvatarp->findAttachmentByID(id_to_remove);
-	if (attachmentp &&
-		attachmentp->isTempAttachment())
-	{	// If this is a temp attachment and we want to remove it, record the ID 
-		// so it will be deleted when attachments are synced up with COF
-		mDoomedTempAttachmentIDs.insert(id_to_remove);
-		//LL_INFOS() << "Will remove temp attachment id " << id_to_remove << LL_ENDL;
-	}
-}
-
-// Find AND REMOVES the given UUID from mDoomedTempAttachmentIDs
-bool LLAppearanceMgr::shouldRemoveTempAttachment(const LLUUID& item_id)
-{
-	doomed_temp_attachments_t::iterator iter = mDoomedTempAttachmentIDs.find(item_id);
-	if (iter != mDoomedTempAttachmentIDs.end())
-	{
-		mDoomedTempAttachmentIDs.erase(iter);
+/** 
+ * @file llappearancemgr.cpp
+ * @brief Manager for initiating appearance changes on the viewer
+ *
+ * $LicenseInfo:firstyear=2004&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 "llviewerprecompiledheaders.h"
+
+#include <boost/lexical_cast.hpp>
+#include "llaccordionctrltab.h"
+#include "llagent.h"
+#include "llagentcamera.h"
+#include "llagentwearables.h"
+#include "llappearancemgr.h"
+#include "llattachmentsmgr.h"
+#include "llcommandhandler.h"
+#include "lleventtimer.h"
+#include "llfloatersidepanelcontainer.h"
+#include "llgesturemgr.h"
+#include "llinventorybridge.h"
+#include "llinventoryfunctions.h"
+#include "llinventoryobserver.h"
+#include "llnotificationsutil.h"
+#include "lloutfitobserver.h"
+#include "lloutfitslist.h"
+#include "llselectmgr.h"
+#include "llsidepanelappearance.h"
+#include "llviewerobjectlist.h"
+#include "llvoavatar.h"
+#include "llvoavatarself.h"
+#include "llviewerregion.h"
+#include "llwearablelist.h"
+#include "llsdutil.h"
+#include "llsdserialize.h"
+#include "llhttpretrypolicy.h"
+#include "llaisapi.h"
+#include "llhttpsdhandler.h"
+#include "llcorehttputil.h"
+#include "llappviewer.h"
+
+#if LL_MSVC
+// disable boost::lexical_cast warning
+#pragma warning (disable:4702)
+#endif
+
+std::string self_av_string()
+{
+	// On logout gAgentAvatarp can already be invalid
+	return isAgentAvatarValid() ? gAgentAvatarp->avString() : "";
+}
+
+// RAII thingy to guarantee that a variable gets reset when the Setter
+// goes out of scope.  More general utility would be handy - TODO:
+// check boost.
+class BoolSetter
+{
+public:
+	BoolSetter(bool& var):
+		mVar(var)
+	{
+		mVar = true;
+	}
+	~BoolSetter()
+	{
+		mVar = false; 
+	}
+private:
+	bool& mVar;
+};
+
+char ORDER_NUMBER_SEPARATOR('@');
+
+class LLOutfitUnLockTimer: public LLEventTimer
+{
+public:
+	LLOutfitUnLockTimer(F32 period) : LLEventTimer(period)
+	{
+		// restart timer on BOF changed event
+		LLOutfitObserver::instance().addBOFChangedCallback(boost::bind(
+				&LLOutfitUnLockTimer::reset, this));
+		stop();
+	}
+
+	/*virtual*/
+	BOOL tick()
+	{
+		if(mEventTimer.hasExpired())
+		{
+			LLAppearanceMgr::instance().setOutfitLocked(false);
+		}
+		return FALSE;
+	}
+	void stop() { mEventTimer.stop(); }
+	void start() { mEventTimer.start(); }
+	void reset() { mEventTimer.reset(); }
+	BOOL getStarted() { return mEventTimer.getStarted(); }
+
+	LLTimer&  getEventTimer() { return mEventTimer;}
+};
+
+// support for secondlife:///app/appearance SLapps
+class LLAppearanceHandler : public LLCommandHandler
+{
+public:
+	// requests will be throttled from a non-trusted browser
+	LLAppearanceHandler() : LLCommandHandler("appearance", UNTRUSTED_THROTTLE) {}
+
+	bool handle(const LLSD& params, const LLSD& query_map, LLMediaCtrl* web)
+	{
+		// support secondlife:///app/appearance/show, but for now we just
+		// make all secondlife:///app/appearance SLapps behave this way
+		if (!LLUI::sSettingGroups["config"]->getBOOL("EnableAppearance"))
+		{
+			LLNotificationsUtil::add("NoAppearance", LLSD(), LLSD(), std::string("SwitchToStandardSkinAndQuit"));
+			return true;
+		}
+
+		LLFloaterSidePanelContainer::showPanel("appearance", LLSD());
+		return true;
+	}
+};
+
+LLAppearanceHandler gAppearanceHandler;
+
+
+LLUUID findDescendentCategoryIDByName(const LLUUID& parent_id, const std::string& name)
+{
+	LLInventoryModel::cat_array_t cat_array;
+	LLInventoryModel::item_array_t item_array;
+	LLNameCategoryCollector has_name(name);
+	gInventory.collectDescendentsIf(parent_id,
+									cat_array,
+									item_array,
+									LLInventoryModel::EXCLUDE_TRASH,
+									has_name);
+	if (0 == cat_array.size())
+		return LLUUID();
+	else
+	{
+		LLViewerInventoryCategory *cat = cat_array.at(0);
+		if (cat)
+			return cat->getUUID();
+		else
+		{
+			LL_WARNS() << "null cat" << LL_ENDL;
+			return LLUUID();
+		}
+	}
+}
+
+// We want this to be much lower (e.g. 15.0 is usually fine), bumping
+// up for now until we can diagnose some cases of very slow response
+// to requests.
+const F32 DEFAULT_RETRY_AFTER_INTERVAL = 300.0;
+
+// Given the current back-end problems, retrying is causing too many
+// duplicate items. Bump this back to 2 once they are resolved (or can
+// leave at 0 if the operations become actually reliable).
+const S32 DEFAULT_MAX_RETRIES = 0;
+
+class LLCallAfterInventoryBatchMgr: public LLEventTimer 
+{
+public:
+	LLCallAfterInventoryBatchMgr(const LLUUID& dst_cat_id,
+								 const std::string& phase_name,
+								 nullary_func_t on_completion_func,
+								 nullary_func_t on_failure_func = no_op,
+								 F32 retry_after = DEFAULT_RETRY_AFTER_INTERVAL,
+								 S32 max_retries = DEFAULT_MAX_RETRIES
+		):
+		mDstCatID(dst_cat_id),
+		mTrackingPhase(phase_name),
+		mOnCompletionFunc(on_completion_func),
+		mOnFailureFunc(on_failure_func),
+		mRetryAfter(retry_after),
+		mMaxRetries(max_retries),
+		mPendingRequests(0),
+		mFailCount(0),
+		mCompletionOrFailureCalled(false),
+		mRetryCount(0),
+		LLEventTimer(5.0)
+	{
+		if (!mTrackingPhase.empty())
+		{
+			selfStartPhase(mTrackingPhase);
+		}
+	}
+
+	void addItems(LLInventoryModel::item_array_t& src_items)
+	{
+		for (LLInventoryModel::item_array_t::const_iterator it = src_items.begin();
+			 it != src_items.end();
+			 ++it)
+		{
+			LLViewerInventoryItem* item = *it;
+			llassert(item);
+			addItem(item->getUUID());
+		}
+	}
+
+	// Request or re-request operation for specified item.
+	void addItem(const LLUUID& item_id)
+	{
+		LL_DEBUGS("Avatar") << "item_id " << item_id << LL_ENDL;
+		if (!requestOperation(item_id))
+		{
+			LL_DEBUGS("Avatar") << "item_id " << item_id << " requestOperation false, skipping" << LL_ENDL;
+			return;
+		}
+
+		mPendingRequests++;
+		// On a re-request, this will reset the timer.
+		mWaitTimes[item_id] = LLTimer();
+		if (mRetryCounts.find(item_id) == mRetryCounts.end())
+		{
+			mRetryCounts[item_id] = 0;
+		}
+		else
+		{
+			mRetryCounts[item_id]++;
+		}
+	}
+
+	virtual bool requestOperation(const LLUUID& item_id) = 0;
+
+	void onOp(const LLUUID& src_id, const LLUUID& dst_id, LLTimer timestamp)
+	{
+		if (ll_frand() < gSavedSettings.getF32("InventoryDebugSimulateLateOpRate"))
+		{
+			LL_WARNS() << "Simulating late operation by punting handling to later" << LL_ENDL;
+			doAfterInterval(boost::bind(&LLCallAfterInventoryBatchMgr::onOp,this,src_id,dst_id,timestamp),
+							mRetryAfter);
+			return;
+		}
+		mPendingRequests--;
+		F32 elapsed = timestamp.getElapsedTimeF32();
+		LL_DEBUGS("Avatar") << "op done, src_id " << src_id << " dst_id " << dst_id << " after " << elapsed << " seconds" << LL_ENDL;
+		if (mWaitTimes.find(src_id) == mWaitTimes.end())
+		{
+			// No longer waiting for this item - either serviced
+			// already or gave up after too many retries.
+			LL_WARNS() << "duplicate or late operation, src_id " << src_id << "dst_id " << dst_id
+					<< " elapsed " << elapsed << " after end " << (S32) mCompletionOrFailureCalled << LL_ENDL;
+		}
+		mTimeStats.push(elapsed);
+		mWaitTimes.erase(src_id);
+		if (mWaitTimes.empty() && !mCompletionOrFailureCalled)
+		{
+			onCompletionOrFailure();
+		}
+	}
+
+	void onCompletionOrFailure()
+	{
+		assert (!mCompletionOrFailureCalled);
+		mCompletionOrFailureCalled = true;
+		
+		// Will never call onCompletion() if any item has been flagged as
+		// a failure - otherwise could wind up with corrupted
+		// outfit, involuntary nudity, etc.
+		reportStats();
+		if (!mTrackingPhase.empty())
+		{
+			selfStopPhase(mTrackingPhase);
+		}
+		if (!mFailCount)
+		{
+			onCompletion();
+		}
+		else
+		{
+			onFailure();
+		}
+	}
+
+	void onFailure()
+	{
+		LL_INFOS() << "failed" << LL_ENDL;
+		mOnFailureFunc();
+	}
+
+	void onCompletion()
+	{
+		LL_INFOS() << "done" << LL_ENDL;
+		mOnCompletionFunc();
+	}
+	
+	// virtual
+	// Will be deleted after returning true - only safe to do this if all callbacks have fired.
+	BOOL tick()
+	{
+		// mPendingRequests will be zero if all requests have been
+		// responded to.  mWaitTimes.empty() will be true if we have
+		// received at least one reply for each UUID.  If requests
+		// have been dropped and retried, these will not necessarily
+		// be the same.  Only safe to return true if all requests have
+		// been serviced, since it will result in this object being
+		// deleted.
+		bool all_done = (mPendingRequests==0);
+
+		if (!mWaitTimes.empty())
+		{
+			LL_WARNS() << "still waiting on " << mWaitTimes.size() << " items" << LL_ENDL;
+			for (std::map<LLUUID,LLTimer>::iterator it = mWaitTimes.begin();
+				 it != mWaitTimes.end();)
+			{
+				// Use a copy of iterator because it may be erased/invalidated.
+				std::map<LLUUID,LLTimer>::iterator curr_it = it;
+				++it;
+				
+				F32 time_waited = curr_it->second.getElapsedTimeF32();
+				S32 retries = mRetryCounts[curr_it->first];
+				if (time_waited > mRetryAfter)
+				{
+					if (retries < mMaxRetries)
+					{
+						LL_DEBUGS("Avatar") << "Waited " << time_waited <<
+							" for " << curr_it->first << ", retrying" << LL_ENDL;
+						mRetryCount++;
+						addItem(curr_it->first);
+					}
+					else
+					{
+						LL_WARNS() << "Giving up on " << curr_it->first << " after too many retries" << LL_ENDL;
+						mWaitTimes.erase(curr_it);
+						mFailCount++;
+					}
+				}
+				if (mWaitTimes.empty())
+				{
+					onCompletionOrFailure();
+				}
+
+			}
+		}
+		return all_done;
+	}
+
+	void reportStats()
+	{
+		LL_DEBUGS("Avatar") << "Phase: " << mTrackingPhase << LL_ENDL;
+		LL_DEBUGS("Avatar") << "mFailCount: " << mFailCount << LL_ENDL;
+		LL_DEBUGS("Avatar") << "mRetryCount: " << mRetryCount << LL_ENDL;
+		LL_DEBUGS("Avatar") << "Times: n " << mTimeStats.getCount() << " min " << mTimeStats.getMinValue() << " max " << mTimeStats.getMaxValue() << LL_ENDL;
+		LL_DEBUGS("Avatar") << "Mean " << mTimeStats.getMean() << " stddev " << mTimeStats.getStdDev() << LL_ENDL;
+	}
+	
+	virtual ~LLCallAfterInventoryBatchMgr()
+	{
+		LL_DEBUGS("Avatar") << "deleting" << LL_ENDL;
+	}
+
+protected:
+	std::string mTrackingPhase;
+	std::map<LLUUID,LLTimer> mWaitTimes;
+	std::map<LLUUID,S32> mRetryCounts;
+	LLUUID mDstCatID;
+	nullary_func_t mOnCompletionFunc;
+	nullary_func_t mOnFailureFunc;
+	F32 mRetryAfter;
+	S32 mMaxRetries;
+	S32 mPendingRequests;
+	S32 mFailCount;
+	S32 mRetryCount;
+	bool mCompletionOrFailureCalled;
+	LLViewerStats::StatsAccumulator mTimeStats;
+};
+
+class LLCallAfterInventoryCopyMgr: public LLCallAfterInventoryBatchMgr
+{
+public:
+	LLCallAfterInventoryCopyMgr(LLInventoryModel::item_array_t& src_items,
+								const LLUUID& dst_cat_id,
+								const std::string& phase_name,
+								nullary_func_t on_completion_func,
+								nullary_func_t on_failure_func = no_op,
+								 F32 retry_after = DEFAULT_RETRY_AFTER_INTERVAL,
+								 S32 max_retries = DEFAULT_MAX_RETRIES
+		):
+		LLCallAfterInventoryBatchMgr(dst_cat_id, phase_name, on_completion_func, on_failure_func, retry_after, max_retries)
+	{
+		addItems(src_items);
+		sInstanceCount++;
+	}
+
+	~LLCallAfterInventoryCopyMgr()
+	{
+		sInstanceCount--;
+	}
+	
+	virtual bool requestOperation(const LLUUID& item_id)
+	{
+		LLViewerInventoryItem *item = gInventory.getItem(item_id);
+		llassert(item);
+		LL_DEBUGS("Avatar") << "copying item " << item_id << LL_ENDL;
+		if (ll_frand() < gSavedSettings.getF32("InventoryDebugSimulateOpFailureRate"))
+		{
+			LL_DEBUGS("Avatar") << "simulating failure by not sending request for item " << item_id << LL_ENDL;
+			return true;
+		}
+		copy_inventory_item(
+			gAgent.getID(),
+			item->getPermissions().getOwner(),
+			item->getUUID(),
+			mDstCatID,
+			std::string(),
+			new LLBoostFuncInventoryCallback(boost::bind(&LLCallAfterInventoryBatchMgr::onOp,this,item_id,_1,LLTimer()))
+			);
+		return true;
+	}
+
+	static S32 getInstanceCount() { return sInstanceCount; }
+	
+private:
+	static S32 sInstanceCount;
+};
+
+S32 LLCallAfterInventoryCopyMgr::sInstanceCount = 0;
+
+class LLWearCategoryAfterCopy: public LLInventoryCallback
+{
+public:
+	LLWearCategoryAfterCopy(bool append):
+		mAppend(append)
+	{}
+
+	// virtual
+	void fire(const LLUUID& id)
+	{
+		// Wear the inventory category.
+		LLInventoryCategory* cat = gInventory.getCategory(id);
+		LLAppearanceMgr::instance().wearInventoryCategoryOnAvatar(cat, mAppend);
+	}
+
+private:
+	bool mAppend;
+};
+
+class LLTrackPhaseWrapper : public LLInventoryCallback
+{
+public:
+	LLTrackPhaseWrapper(const std::string& phase_name, LLPointer<LLInventoryCallback> cb = NULL):
+		mTrackingPhase(phase_name),
+		mCB(cb)
+	{
+		selfStartPhase(mTrackingPhase);
+	}
+
+	// virtual
+	void fire(const LLUUID& id)
+	{
+		if (mCB)
+		{
+			mCB->fire(id);
+		}
+	}
+
+	// virtual
+	~LLTrackPhaseWrapper()
+	{
+		selfStopPhase(mTrackingPhase);
+	}
+
+protected:
+	std::string mTrackingPhase;
+	LLPointer<LLInventoryCallback> mCB;
+};
+
+LLUpdateAppearanceOnDestroy::LLUpdateAppearanceOnDestroy(bool enforce_item_restrictions,
+														 bool enforce_ordering,
+														 nullary_func_t post_update_func 
+	):
+	mFireCount(0),
+	mEnforceItemRestrictions(enforce_item_restrictions),
+	mEnforceOrdering(enforce_ordering),
+	mPostUpdateFunc(post_update_func)
+{
+	selfStartPhase("update_appearance_on_destroy");
+}
+
+void LLUpdateAppearanceOnDestroy::fire(const LLUUID& inv_item)
+{
+	LLViewerInventoryItem* item = (LLViewerInventoryItem*)gInventory.getItem(inv_item);
+	const std::string item_name = item ? item->getName() : "ITEM NOT FOUND";
+#ifndef LL_RELEASE_FOR_DOWNLOAD
+	LL_DEBUGS("Avatar") << self_av_string() << "callback fired [ name:" << item_name << " UUID:" << inv_item << " count:" << mFireCount << " ] " << LL_ENDL;
+#endif
+	mFireCount++;
+}
+
+LLUpdateAppearanceOnDestroy::~LLUpdateAppearanceOnDestroy()
+{
+	if (!LLApp::isExiting())
+	{
+		// speculative fix for MAINT-1150
+		LL_INFOS("Avatar") << self_av_string() << "done update appearance on destroy" << LL_ENDL;
+
+		selfStopPhase("update_appearance_on_destroy");
+
+		LLAppearanceMgr::instance().updateAppearanceFromCOF(mEnforceItemRestrictions,
+															mEnforceOrdering,
+															mPostUpdateFunc);
+	}
+}
+
+LLUpdateAppearanceAndEditWearableOnDestroy::LLUpdateAppearanceAndEditWearableOnDestroy(const LLUUID& item_id):
+	mItemID(item_id)
+{
+}
+
+void edit_wearable_and_customize_avatar(LLUUID item_id)
+{
+	// Start editing the item if previously requested.
+	gAgentWearables.editWearableIfRequested(item_id);
+	
+	// TODO: camera mode may not be changed if a debug setting is tweaked
+	if( gAgentCamera.cameraCustomizeAvatar() )
+	{
+		// If we're in appearance editing mode, the current tab may need to be refreshed
+		LLSidepanelAppearance *panel = dynamic_cast<LLSidepanelAppearance*>(
+			LLFloaterSidePanelContainer::getPanel("appearance"));
+		if (panel)
+		{
+			panel->showDefaultSubpart();
+		}
+	}
+}
+
+LLUpdateAppearanceAndEditWearableOnDestroy::~LLUpdateAppearanceAndEditWearableOnDestroy()
+{
+	if (!LLApp::isExiting())
+	{
+		LLAppearanceMgr::instance().updateAppearanceFromCOF(
+			true,true,
+			boost::bind(edit_wearable_and_customize_avatar, mItemID));
+	}
+}
+
+
+struct LLFoundData
+{
+	LLFoundData() :
+		mAssetType(LLAssetType::AT_NONE),
+		mWearableType(LLWearableType::WT_INVALID),
+		mWearable(NULL) {}
+
+	LLFoundData(const LLUUID& item_id,
+				const LLUUID& asset_id,
+				const std::string& name,
+				const LLAssetType::EType& asset_type,
+				const LLWearableType::EType& wearable_type,
+				const bool is_replacement = false
+		) :
+		mItemID(item_id),
+		mAssetID(asset_id),
+		mName(name),
+		mAssetType(asset_type),
+		mWearableType(wearable_type),
+		mIsReplacement(is_replacement),
+		mWearable( NULL ) {}
+	
+	LLUUID mItemID;
+	LLUUID mAssetID;
+	std::string mName;
+	LLAssetType::EType mAssetType;
+	LLWearableType::EType mWearableType;
+	LLViewerWearable* mWearable;
+	bool mIsReplacement;
+};
+
+	
+class LLWearableHoldingPattern
+{
+	LOG_CLASS(LLWearableHoldingPattern);
+
+public:
+	LLWearableHoldingPattern();
+	~LLWearableHoldingPattern();
+
+	bool pollFetchCompletion();
+	void onFetchCompletion();
+	bool isFetchCompleted();
+	bool isTimedOut();
+
+	void checkMissingWearables();
+	bool pollMissingWearables();
+	bool isMissingCompleted();
+	void recoverMissingWearable(LLWearableType::EType type);
+	void clearCOFLinksForMissingWearables();
+	
+	void onWearableAssetFetch(LLViewerWearable *wearable);
+	void onAllComplete();
+
+	typedef std::list<LLFoundData> found_list_t;
+	found_list_t& getFoundList();
+	void eraseTypeToLink(LLWearableType::EType type);
+	void eraseTypeToRecover(LLWearableType::EType type);
+	void setObjItems(const LLInventoryModel::item_array_t& items);
+	void setGestItems(const LLInventoryModel::item_array_t& items);
+	bool isMostRecent();
+	void handleLateArrivals();
+	void resetTime(F32 timeout);
+	static S32 countActive() { return sActiveHoldingPatterns.size(); }
+	S32 index() { return mIndex; }
+	
+private:
+	found_list_t mFoundList;
+	LLInventoryModel::item_array_t mObjItems;
+	LLInventoryModel::item_array_t mGestItems;
+	typedef std::set<S32> type_set_t;
+	type_set_t mTypesToRecover;
+	type_set_t mTypesToLink;
+	S32 mResolved;
+	LLTimer mWaitTime;
+	bool mFired;
+	typedef std::set<LLWearableHoldingPattern*> type_set_hp;
+	static type_set_hp sActiveHoldingPatterns;
+	static S32 sNextIndex;
+	S32 mIndex;
+	bool mIsMostRecent;
+	std::set<LLViewerWearable*> mLateArrivals;
+	bool mIsAllComplete;
+};
+
+LLWearableHoldingPattern::type_set_hp LLWearableHoldingPattern::sActiveHoldingPatterns;
+S32 LLWearableHoldingPattern::sNextIndex = 0;
+
+LLWearableHoldingPattern::LLWearableHoldingPattern():
+	mResolved(0),
+	mFired(false),
+	mIsMostRecent(true),
+	mIsAllComplete(false)
+{
+	if (countActive()>0)
+	{
+		LL_INFOS() << "Creating LLWearableHoldingPattern when "
+				   << countActive()
+				   << " other attempts are active."
+				   << " Flagging others as invalid."
+				   << LL_ENDL;
+		for (type_set_hp::iterator it = sActiveHoldingPatterns.begin();
+			 it != sActiveHoldingPatterns.end();
+			 ++it)
+		{
+			(*it)->mIsMostRecent = false;
+		}
+			 
+	}
+	mIndex = sNextIndex++;
+	sActiveHoldingPatterns.insert(this);
+	LL_DEBUGS("Avatar") << "HP " << index() << " created" << LL_ENDL;
+	selfStartPhase("holding_pattern");
+}
+
+LLWearableHoldingPattern::~LLWearableHoldingPattern()
+{
+	sActiveHoldingPatterns.erase(this);
+	if (isMostRecent())
+	{
+		selfStopPhase("holding_pattern");
+	}
+	LL_DEBUGS("Avatar") << "HP " << index() << " deleted" << LL_ENDL;
+}
+
+bool LLWearableHoldingPattern::isMostRecent()
+{
+	return mIsMostRecent;
+}
+
+LLWearableHoldingPattern::found_list_t& LLWearableHoldingPattern::getFoundList()
+{
+	return mFoundList;
+}
+
+void LLWearableHoldingPattern::eraseTypeToLink(LLWearableType::EType type)
+{
+	mTypesToLink.erase(type);
+}
+
+void LLWearableHoldingPattern::eraseTypeToRecover(LLWearableType::EType type)
+{
+	mTypesToRecover.erase(type);
+}
+
+void LLWearableHoldingPattern::setObjItems(const LLInventoryModel::item_array_t& items)
+{
+	mObjItems = items;
+}
+
+void LLWearableHoldingPattern::setGestItems(const LLInventoryModel::item_array_t& items)
+{
+	mGestItems = items;
+}
+
+bool LLWearableHoldingPattern::isFetchCompleted()
+{
+	return (mResolved >= (S32)getFoundList().size()); // have everything we were waiting for?
+}
+
+bool LLWearableHoldingPattern::isTimedOut()
+{
+	return mWaitTime.hasExpired();
+}
+
+void LLWearableHoldingPattern::checkMissingWearables()
+{
+	if (!isMostRecent())
+	{
+		// runway why don't we actually skip here?
+		LL_WARNS() << self_av_string() << "skipping because LLWearableHolding pattern is invalid (superceded by later outfit request)" << LL_ENDL;
+	}
+
+	std::vector<S32> found_by_type(LLWearableType::WT_COUNT,0);
+	std::vector<S32> requested_by_type(LLWearableType::WT_COUNT,0);
+	for (found_list_t::iterator it = getFoundList().begin(); it != getFoundList().end(); ++it)
+	{
+		LLFoundData &data = *it;
+		if (data.mWearableType < LLWearableType::WT_COUNT)
+			requested_by_type[data.mWearableType]++;
+		if (data.mWearable)
+			found_by_type[data.mWearableType]++;
+	}
+
+	for (S32 type = 0; type < LLWearableType::WT_COUNT; ++type)
+	{
+		if (requested_by_type[type] > found_by_type[type])
+		{
+			LL_WARNS() << self_av_string() << "got fewer wearables than requested, type " << type << ": requested " << requested_by_type[type] << ", found " << found_by_type[type] << LL_ENDL;
+		}
+		if (found_by_type[type] > 0)
+			continue;
+		if (
+			// If at least one wearable of certain types (pants/shirt/skirt)
+			// was requested but none was found, create a default asset as a replacement.
+			// In all other cases, don't do anything.
+			// For critical types (shape/hair/skin/eyes), this will keep the avatar as a cloud 
+			// due to logic in LLVOAvatarSelf::getIsCloud().
+			// For non-critical types (tatoo, socks, etc.) the wearable will just be missing.
+			(requested_by_type[type] > 0) &&  
+			((type == LLWearableType::WT_PANTS) || (type == LLWearableType::WT_SHIRT) || (type == LLWearableType::WT_SKIRT)))
+		{
+			mTypesToRecover.insert(type);
+			mTypesToLink.insert(type);
+			recoverMissingWearable((LLWearableType::EType)type);
+			LL_WARNS() << self_av_string() << "need to replace " << type << LL_ENDL; 
+		}
+	}
+
+	resetTime(60.0F);
+
+	if (isMostRecent())
+	{
+		selfStartPhase("get_missing_wearables_2");
+	}
+	if (!pollMissingWearables())
+	{
+		doOnIdleRepeating(boost::bind(&LLWearableHoldingPattern::pollMissingWearables,this));
+	}
+}
+
+void LLWearableHoldingPattern::onAllComplete()
+{
+	if (isAgentAvatarValid())
+	{
+		gAgentAvatarp->outputRezTiming("Agent wearables fetch complete");
+	}
+
+	if (!isMostRecent())
+	{
+		// runway need to skip here?
+		LL_WARNS() << self_av_string() << "skipping because LLWearableHolding pattern is invalid (superceded by later outfit request)" << LL_ENDL;
+	}
+
+	// Activate all gestures in this folder
+	if (mGestItems.size() > 0)
+	{
+		LL_DEBUGS("Avatar") << self_av_string() << "Activating " << mGestItems.size() << " gestures" << LL_ENDL;
+		
+		LLGestureMgr::instance().activateGestures(mGestItems);
+		
+		// Update the inventory item labels to reflect the fact
+		// they are active.
+		LLViewerInventoryCategory* catp =
+			gInventory.getCategory(LLAppearanceMgr::instance().getCOF());
+		
+		if (catp)
+		{
+			gInventory.updateCategory(catp);
+			gInventory.notifyObservers();
+		}
+	}
+
+	if (isAgentAvatarValid())
+	{
+		LL_DEBUGS("Avatar") << self_av_string() << "Updating " << mObjItems.size() << " attachments" << LL_ENDL;
+		LLAgentWearables::llvo_vec_t objects_to_remove;
+		LLAgentWearables::llvo_vec_t objects_to_retain;
+		LLInventoryModel::item_array_t items_to_add;
+
+		LLAgentWearables::findAttachmentsAddRemoveInfo(mObjItems,
+													   objects_to_remove,
+													   objects_to_retain,
+													   items_to_add);
+
+		LL_DEBUGS("Avatar") << self_av_string() << "Removing " << objects_to_remove.size()
+							<< " attachments" << LL_ENDL;
+
+		// Here we remove the attachment pos overrides for *all*
+		// attachments, even those that are not being removed. This is
+		// needed to get joint positions all slammed down to their
+		// pre-attachment states.
+		gAgentAvatarp->clearAttachmentPosOverrides();
+
+		// Take off the attachments that will no longer be in the outfit.
+		LLAgentWearables::userRemoveMultipleAttachments(objects_to_remove);
+		
+		// Update wearables.
+		LL_INFOS("Avatar") << self_av_string() << "HP " << index() << " updating agent wearables with "
+						   << mResolved << " wearable items " << LL_ENDL;
+		LLAppearanceMgr::instance().updateAgentWearables(this);
+		
+		// Restore attachment pos overrides for the attachments that
+		// are remaining in the outfit.
+		for (LLAgentWearables::llvo_vec_t::iterator it = objects_to_retain.begin();
+			 it != objects_to_retain.end();
+			 ++it)
+		{
+			LLViewerObject *objectp = *it;
+			gAgentAvatarp->addAttachmentPosOverridesForObject(objectp);
+		}
+		
+		// Add new attachments to match those requested.
+		LL_DEBUGS("Avatar") << self_av_string() << "Adding " << items_to_add.size() << " attachments" << LL_ENDL;
+		LLAgentWearables::userAttachMultipleAttachments(items_to_add);
+	}
+
+	if (isFetchCompleted() && isMissingCompleted())
+	{
+		// Only safe to delete if all wearable callbacks and all missing wearables completed.
+		delete this;
+	}
+	else
+	{
+		mIsAllComplete = true;
+		handleLateArrivals();
+	}
+}
+
+void LLWearableHoldingPattern::onFetchCompletion()
+{
+	if (isMostRecent())
+	{
+		selfStopPhase("get_wearables_2");
+	}
+		
+	if (!isMostRecent())
+	{
+		// runway skip here?
+		LL_WARNS() << self_av_string() << "skipping because LLWearableHolding pattern is invalid (superceded by later outfit request)" << LL_ENDL;
+	}
+
+	checkMissingWearables();
+}
+
+// Runs as an idle callback until all wearables are fetched (or we time out).
+bool LLWearableHoldingPattern::pollFetchCompletion()
+{
+	if (!isMostRecent())
+	{
+		// runway skip here?
+		LL_WARNS() << self_av_string() << "skipping because LLWearableHolding pattern is invalid (superceded by later outfit request)" << LL_ENDL;
+	}
+
+	bool completed = isFetchCompleted();
+	bool timed_out = isTimedOut();
+	bool done = completed || timed_out;
+
+	if (done)
+	{
+		LL_INFOS("Avatar") << self_av_string() << "HP " << index() << " polling, done status: " << completed << " timed out " << timed_out
+				<< " elapsed " << mWaitTime.getElapsedTimeF32() << LL_ENDL;
+
+		mFired = true;
+		
+		if (timed_out)
+		{
+			LL_WARNS() << self_av_string() << "Exceeded max wait time for wearables, updating appearance based on what has arrived" << LL_ENDL;
+		}
+
+		onFetchCompletion();
+	}
+	return done;
+}
+
+void recovered_item_link_cb(const LLUUID& item_id, LLWearableType::EType type, LLViewerWearable *wearable, LLWearableHoldingPattern* holder)
+{
+	if (!holder->isMostRecent())
+	{
+		LL_WARNS() << "HP " << holder->index() << " skipping because LLWearableHolding pattern is invalid (superceded by later outfit request)" << LL_ENDL;
+		// runway skip here?
+	}
+
+	LL_INFOS() << "HP " << holder->index() << " recovered item link for type " << type << LL_ENDL;
+	holder->eraseTypeToLink(type);
+	// Add wearable to FoundData for actual wearing
+	LLViewerInventoryItem *item = gInventory.getItem(item_id);
+	LLViewerInventoryItem *linked_item = item ? item->getLinkedItem() : NULL;
+
+	if (linked_item)
+	{
+		gInventory.addChangedMask(LLInventoryObserver::LABEL, linked_item->getUUID());
+			
+		if (item)
+		{
+			LLFoundData found(linked_item->getUUID(),
+							  linked_item->getAssetUUID(),
+							  linked_item->getName(),
+							  linked_item->getType(),
+							  linked_item->isWearableType() ? linked_item->getWearableType() : LLWearableType::WT_INVALID,
+							  true // is replacement
+				);
+			found.mWearable = wearable;
+			holder->getFoundList().push_front(found);
+		}
+		else
+		{
+			LL_WARNS() << self_av_string() << "inventory link not found for recovered wearable" << LL_ENDL;
+		}
+	}
+	else
+	{
+		LL_WARNS() << self_av_string() << "HP " << holder->index() << " inventory link not found for recovered wearable" << LL_ENDL;
+	}
+}
+
+void recovered_item_cb(const LLUUID& item_id, LLWearableType::EType type, LLViewerWearable *wearable, LLWearableHoldingPattern* holder)
+{
+	if (!holder->isMostRecent())
+	{
+		// runway skip here?
+		LL_WARNS() << self_av_string() << "skipping because LLWearableHolding pattern is invalid (superceded by later outfit request)" << LL_ENDL;
+	}
+
+	LL_DEBUGS("Avatar") << self_av_string() << "Recovered item for type " << type << LL_ENDL;
+	LLConstPointer<LLInventoryObject> itemp = gInventory.getItem(item_id);
+	wearable->setItemID(item_id);
+	holder->eraseTypeToRecover(type);
+	llassert(itemp);
+	if (itemp)
+	{
+		LLPointer<LLInventoryCallback> cb = new LLBoostFuncInventoryCallback(boost::bind(recovered_item_link_cb,_1,type,wearable,holder));
+
+		link_inventory_object(LLAppearanceMgr::instance().getCOF(), itemp, cb);
+	}
+}
+
+void LLWearableHoldingPattern::recoverMissingWearable(LLWearableType::EType type)
+{
+	if (!isMostRecent())
+	{
+		// runway skip here?
+		LL_WARNS() << self_av_string() << "skipping because LLWearableHolding pattern is invalid (superceded by later outfit request)" << LL_ENDL;
+	}
+	
+		// Try to recover by replacing missing wearable with a new one.
+	LLNotificationsUtil::add("ReplacedMissingWearable");
+	LL_DEBUGS() << "Wearable " << LLWearableType::getTypeLabel(type)
+				<< " could not be downloaded.  Replaced inventory item with default wearable." << LL_ENDL;
+	LLViewerWearable* wearable = LLWearableList::instance().createNewWearable(type, gAgentAvatarp);
+
+	// Add a new one in the lost and found folder.
+	const LLUUID lost_and_found_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LOST_AND_FOUND);
+	LLPointer<LLInventoryCallback> cb = new LLBoostFuncInventoryCallback(boost::bind(recovered_item_cb,_1,type,wearable,this));
+
+	create_inventory_item(gAgent.getID(),
+						  gAgent.getSessionID(),
+						  lost_and_found_id,
+						  wearable->getTransactionID(),
+						  wearable->getName(),
+						  wearable->getDescription(),
+						  wearable->getAssetType(),
+						  LLInventoryType::IT_WEARABLE,
+						  wearable->getType(),
+						  wearable->getPermissions().getMaskNextOwner(),
+						  cb);
+}
+
+bool LLWearableHoldingPattern::isMissingCompleted()
+{
+	return mTypesToLink.size()==0 && mTypesToRecover.size()==0;
+}
+
+void LLWearableHoldingPattern::clearCOFLinksForMissingWearables()
+{
+	for (found_list_t::iterator it = getFoundList().begin(); it != getFoundList().end(); ++it)
+	{
+		LLFoundData &data = *it;
+		if ((data.mWearableType < LLWearableType::WT_COUNT) && (!data.mWearable))
+		{
+			// Wearable link that was never resolved; remove links to it from COF
+			LL_INFOS("Avatar") << self_av_string() << "HP " << index() << " removing link for unresolved item " << data.mItemID.asString() << LL_ENDL;
+			LLAppearanceMgr::instance().removeCOFItemLinks(data.mItemID);
+		}
+	}
+}
+
+bool LLWearableHoldingPattern::pollMissingWearables()
+{
+	if (!isMostRecent())
+	{
+		// runway skip here?
+		LL_WARNS() << self_av_string() << "skipping because LLWearableHolding pattern is invalid (superceded by later outfit request)" << LL_ENDL;
+	}
+	
+	bool timed_out = isTimedOut();
+	bool missing_completed = isMissingCompleted();
+	bool done = timed_out || missing_completed;
+
+	if (!done)
+	{
+		LL_INFOS("Avatar") << self_av_string() << "HP " << index() << " polling missing wearables, waiting for items " << mTypesToRecover.size()
+				<< " links " << mTypesToLink.size()
+				<< " wearables, timed out " << timed_out
+				<< " elapsed " << mWaitTime.getElapsedTimeF32()
+				<< " done " << done << LL_ENDL;
+	}
+
+	if (done)
+	{
+		if (isMostRecent())
+		{
+			selfStopPhase("get_missing_wearables_2");
+		}
+
+		gAgentAvatarp->debugWearablesLoaded();
+
+		// BAP - if we don't call clearCOFLinksForMissingWearables()
+		// here, we won't have to add the link back in later if the
+		// wearable arrives late.  This is to avoid corruption of
+		// wearable ordering info.  Also has the effect of making
+		// unworn item links visible in the COF under some
+		// circumstances.
+
+		//clearCOFLinksForMissingWearables();
+		onAllComplete();
+	}
+	return done;
+}
+
+// Handle wearables that arrived after the timeout period expired.
+void LLWearableHoldingPattern::handleLateArrivals()
+{
+	// Only safe to run if we have previously finished the missing
+	// wearables and other processing - otherwise we could be in some
+	// intermediate state - but have not been superceded by a later
+	// outfit change request.
+	if (mLateArrivals.size() == 0)
+	{
+		// Nothing to process.
+		return;
+	}
+	if (!isMostRecent())
+	{
+		LL_WARNS() << self_av_string() << "Late arrivals not handled - outfit change no longer valid" << LL_ENDL;
+	}
+	if (!mIsAllComplete)
+	{
+		LL_WARNS() << self_av_string() << "Late arrivals not handled - in middle of missing wearables processing" << LL_ENDL;
+	}
+
+	LL_INFOS("Avatar") << self_av_string() << "HP " << index() << " need to handle " << mLateArrivals.size() << " late arriving wearables" << LL_ENDL;
+
+	// Update mFoundList using late-arriving wearables.
+	std::set<LLWearableType::EType> replaced_types;
+	for (LLWearableHoldingPattern::found_list_t::iterator iter = getFoundList().begin();
+		 iter != getFoundList().end(); ++iter)
+	{
+		LLFoundData& data = *iter;
+		for (std::set<LLViewerWearable*>::iterator wear_it = mLateArrivals.begin();
+			 wear_it != mLateArrivals.end();
+			 ++wear_it)
+		{
+			LLViewerWearable *wearable = *wear_it;
+
+			if(wearable->getAssetID() == data.mAssetID)
+			{
+				data.mWearable = wearable;
+
+				replaced_types.insert(data.mWearableType);
+
+				// BAP - if we didn't call
+				// clearCOFLinksForMissingWearables() earlier, we
+				// don't need to restore the link here.  Fixes
+				// wearable ordering problems.
+
+				// LLAppearanceMgr::instance().addCOFItemLink(data.mItemID,false);
+
+				// BAP failing this means inventory or asset server
+				// are corrupted in a way we don't handle.
+				llassert((data.mWearableType < LLWearableType::WT_COUNT) && (wearable->getType() == data.mWearableType));
+				break;
+			}
+		}
+	}
+
+	// Remove COF links for any default wearables previously used to replace the late arrivals.
+	// All this pussyfooting around with a while loop and explicit
+	// iterator incrementing is to allow removing items from the list
+	// without clobbering the iterator we're using to navigate.
+	LLWearableHoldingPattern::found_list_t::iterator iter = getFoundList().begin();
+	while (iter != getFoundList().end())
+	{
+		LLFoundData& data = *iter;
+
+		// If an item of this type has recently shown up, removed the corresponding replacement wearable from COF.
+		if (data.mWearable && data.mIsReplacement &&
+			replaced_types.find(data.mWearableType) != replaced_types.end())
+		{
+			LLAppearanceMgr::instance().removeCOFItemLinks(data.mItemID);
+			std::list<LLFoundData>::iterator clobber_ator = iter;
+			++iter;
+			getFoundList().erase(clobber_ator);
+		}
+		else
+		{
+			++iter;
+		}
+	}
+
+	// Clear contents of late arrivals.
+	mLateArrivals.clear();
+
+	// Update appearance based on mFoundList
+	LLAppearanceMgr::instance().updateAgentWearables(this);
+}
+
+void LLWearableHoldingPattern::resetTime(F32 timeout)
+{
+	mWaitTime.reset();
+	mWaitTime.setTimerExpirySec(timeout);
+}
+
+void LLWearableHoldingPattern::onWearableAssetFetch(LLViewerWearable *wearable)
+{
+	if (!isMostRecent())
+	{
+		LL_WARNS() << self_av_string() << "skipping because LLWearableHolding pattern is invalid (superceded by later outfit request)" << LL_ENDL;
+	}
+	
+	mResolved += 1;  // just counting callbacks, not successes.
+	LL_DEBUGS("Avatar") << self_av_string() << "HP " << index() << " resolved " << mResolved << "/" << getFoundList().size() << LL_ENDL;
+	if (!wearable)
+	{
+		LL_WARNS() << self_av_string() << "no wearable found" << LL_ENDL;
+	}
+
+	if (mFired)
+	{
+		LL_WARNS() << self_av_string() << "called after holder fired" << LL_ENDL;
+		if (wearable)
+		{
+			mLateArrivals.insert(wearable);
+			if (mIsAllComplete)
+			{
+				handleLateArrivals();
+			}
+		}
+		return;
+	}
+
+	if (!wearable)
+	{
+		return;
+	}
+
+	for (LLWearableHoldingPattern::found_list_t::iterator iter = getFoundList().begin();
+		 iter != getFoundList().end(); ++iter)
+	{
+		LLFoundData& data = *iter;
+		if(wearable->getAssetID() == data.mAssetID)
+		{
+			// Failing this means inventory or asset server are corrupted in a way we don't handle.
+			if ((data.mWearableType >= LLWearableType::WT_COUNT) || (wearable->getType() != data.mWearableType))
+			{
+				LL_WARNS() << self_av_string() << "recovered wearable but type invalid. inventory wearable type: " << data.mWearableType << " asset wearable type: " << wearable->getType() << LL_ENDL;
+				break;
+			}
+
+			data.mWearable = wearable;
+		}
+	}
+}
+
+static void onWearableAssetFetch(LLViewerWearable* wearable, void* data)
+{
+	LLWearableHoldingPattern* holder = (LLWearableHoldingPattern*)data;
+	holder->onWearableAssetFetch(wearable);
+}
+
+
+static void removeDuplicateItems(LLInventoryModel::item_array_t& items)
+{
+	LLInventoryModel::item_array_t new_items;
+	std::set<LLUUID> items_seen;
+	std::deque<LLViewerInventoryItem*> tmp_list;
+	// Traverse from the front and keep the first of each item
+	// encountered, so we actually keep the *last* of each duplicate
+	// item.  This is needed to give the right priority when adding
+	// duplicate items to an existing outfit.
+	for (S32 i=items.size()-1; i>=0; i--)
+	{
+		LLViewerInventoryItem *item = items.at(i);
+		LLUUID item_id = item->getLinkedUUID();
+		if (items_seen.find(item_id)!=items_seen.end())
+			continue;
+		items_seen.insert(item_id);
+		tmp_list.push_front(item);
+	}
+	for (std::deque<LLViewerInventoryItem*>::iterator it = tmp_list.begin();
+		 it != tmp_list.end();
+		 ++it)
+	{
+		new_items.push_back(*it);
+	}
+	items = new_items;
+}
+
+const LLUUID LLAppearanceMgr::getCOF() const
+{
+	return gInventory.findCategoryUUIDForType(LLFolderType::FT_CURRENT_OUTFIT);
+}
+
+S32 LLAppearanceMgr::getCOFVersion() const
+{
+	LLViewerInventoryCategory *cof = gInventory.getCategory(getCOF());
+	if (cof)
+	{
+		return cof->getVersion();
+	}
+	else
+	{
+		return LLViewerInventoryCategory::VERSION_UNKNOWN;
+	}
+}
+
+const LLViewerInventoryItem* LLAppearanceMgr::getBaseOutfitLink()
+{
+	const LLUUID& current_outfit_cat = getCOF();
+	LLInventoryModel::cat_array_t cat_array;
+	LLInventoryModel::item_array_t item_array;
+	// Can't search on FT_OUTFIT since links to categories return FT_CATEGORY for type since they don't
+	// return preferred type.
+	LLIsType is_category( LLAssetType::AT_CATEGORY ); 
+	gInventory.collectDescendentsIf(current_outfit_cat,
+									cat_array,
+									item_array,
+									false,
+									is_category);
+	for (LLInventoryModel::item_array_t::const_iterator iter = item_array.begin();
+		 iter != item_array.end();
+		 iter++)
+	{
+		const LLViewerInventoryItem *item = (*iter);
+		const LLViewerInventoryCategory *cat = item->getLinkedCategory();
+		if (cat && cat->getPreferredType() == LLFolderType::FT_OUTFIT)
+		{
+			const LLUUID parent_id = cat->getParentUUID();
+			LLViewerInventoryCategory*  parent_cat =  gInventory.getCategory(parent_id);
+			// if base outfit moved to trash it means that we don't have base outfit
+			if (parent_cat != NULL && parent_cat->getPreferredType() == LLFolderType::FT_TRASH)
+			{
+				return NULL;
+			}
+			return item;
+		}
+	}
+	return NULL;
+}
+
+bool LLAppearanceMgr::getBaseOutfitName(std::string& name)
+{
+	const LLViewerInventoryItem* outfit_link = getBaseOutfitLink();
+	if(outfit_link)
+	{
+		const LLViewerInventoryCategory *cat = outfit_link->getLinkedCategory();
+		if (cat)
+		{
+			name = cat->getName();
+			return true;
+		}
+	}
+	return false;
+}
+
+const LLUUID LLAppearanceMgr::getBaseOutfitUUID()
+{
+	const LLViewerInventoryItem* outfit_link = getBaseOutfitLink();
+	if (!outfit_link || !outfit_link->getIsLinkType()) return LLUUID::null;
+
+	const LLViewerInventoryCategory* outfit_cat = outfit_link->getLinkedCategory();
+	if (!outfit_cat) return LLUUID::null;
+
+	if (outfit_cat->getPreferredType() != LLFolderType::FT_OUTFIT)
+	{
+		LL_WARNS() << "Expected outfit type:" << LLFolderType::FT_OUTFIT << " but got type:" << outfit_cat->getType() << " for folder name:" << outfit_cat->getName() << LL_ENDL;
+		return LLUUID::null;
+	}
+
+	return outfit_cat->getUUID();
+}
+
+void wear_on_avatar_cb(const LLUUID& inv_item, bool do_replace = false)
+{
+	if (inv_item.isNull())
+		return;
+	
+	LLViewerInventoryItem *item = gInventory.getItem(inv_item);
+	if (item)
+	{
+		LLAppearanceMgr::instance().wearItemOnAvatar(inv_item, true, do_replace);
+	}
+}
+
+bool LLAppearanceMgr::wearItemOnAvatar(const LLUUID& item_id_to_wear,
+									   bool do_update,
+									   bool replace,
+									   LLPointer<LLInventoryCallback> cb)
+{
+
+	if (item_id_to_wear.isNull()) return false;
+
+	// *TODO: issue with multi-wearable should be fixed:
+	// in this case this method will be called N times - loading started for each item
+	// and than N times will be called - loading completed for each item.
+	// That means subscribers will be notified that loading is done after first item in a batch is worn.
+	// (loading indicator disappears for example before all selected items are worn)
+	// Have not fix this issue for 2.1 because of stability reason. EXT-7777.
+
+	// Disabled for now because it is *not* acceptable to call updateAppearanceFromCOF() multiple times
+//	gAgentWearables.notifyLoadingStarted();
+
+	LLViewerInventoryItem* item_to_wear = gInventory.getItem(item_id_to_wear);
+	if (!item_to_wear) return false;
+
+	if (gInventory.isObjectDescendentOf(item_to_wear->getUUID(), gInventory.getLibraryRootFolderID()))
+	{
+		LLPointer<LLInventoryCallback> cb = new LLBoostFuncInventoryCallback(boost::bind(wear_on_avatar_cb,_1,replace));
+		copy_inventory_item(gAgent.getID(), item_to_wear->getPermissions().getOwner(), item_to_wear->getUUID(), LLUUID::null, std::string(), cb);
+		return false;
+	} 
+	else if (!gInventory.isObjectDescendentOf(item_to_wear->getUUID(), gInventory.getRootFolderID()))
+	{
+		return false; // not in library and not in agent's inventory
+	}
+	else if (gInventory.isObjectDescendentOf(item_to_wear->getUUID(), gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH)))
+	{
+		LLNotificationsUtil::add("CannotWearTrash");
+		return false;
+	}
+	else if (isLinkedInCOF(item_to_wear->getUUID())) // EXT-84911
+	{
+		return false;
+	}
+
+	switch (item_to_wear->getType())
+	{
+		case LLAssetType::AT_CLOTHING:
+		if (gAgentWearables.areWearablesLoaded())
+		{
+			if (!cb && do_update)
+			{
+				cb = new LLUpdateAppearanceAndEditWearableOnDestroy(item_id_to_wear);
+			}
+			S32 wearable_count = gAgentWearables.getWearableCount(item_to_wear->getWearableType());
+			if ((replace && wearable_count != 0) ||
+				(wearable_count >= LLAgentWearables::MAX_CLOTHING_PER_TYPE) )
+			{
+				LLUUID item_id = gAgentWearables.getWearableItemID(item_to_wear->getWearableType(),
+																   wearable_count-1);
+				removeCOFItemLinks(item_id, cb);
+			}
+
+			addCOFItemLink(item_to_wear, cb);
+		} 
+		break;
+
+		case LLAssetType::AT_BODYPART:
+		// TODO: investigate wearables may not be loaded at this point EXT-8231
+		
+		// Remove the existing wearables of the same type.
+		// Remove existing body parts anyway because we must not be able to wear e.g. two skins.
+		removeCOFLinksOfType(item_to_wear->getWearableType());
+		if (!cb && do_update)
+		{
+			cb = new LLUpdateAppearanceAndEditWearableOnDestroy(item_id_to_wear);
+		}
+		addCOFItemLink(item_to_wear, cb);
+		break;
+
+		case LLAssetType::AT_OBJECT:
+		rez_attachment(item_to_wear, NULL, replace);
+		break;
+
+		default: return false;;
+	}
+
+	return true;
+}
+
+// Update appearance from outfit folder.
+void LLAppearanceMgr::changeOutfit(bool proceed, const LLUUID& category, bool append)
+{
+	if (!proceed)
+		return;
+	LLAppearanceMgr::instance().updateCOF(category,append);
+}
+
+void LLAppearanceMgr::replaceCurrentOutfit(const LLUUID& new_outfit)
+{
+	LLViewerInventoryCategory* cat = gInventory.getCategory(new_outfit);
+	wearInventoryCategory(cat, false, false);
+}
+
+// Open outfit renaming dialog.
+void LLAppearanceMgr::renameOutfit(const LLUUID& outfit_id)
+{
+	LLViewerInventoryCategory* cat = gInventory.getCategory(outfit_id);
+	if (!cat)
+	{
+		return;
+	}
+
+	LLSD args;
+	args["NAME"] = cat->getName();
+
+	LLSD payload;
+	payload["cat_id"] = outfit_id;
+
+	LLNotificationsUtil::add("RenameOutfit", args, payload, boost::bind(onOutfitRename, _1, _2));
+}
+
+// User typed new outfit name.
+// static
+void LLAppearanceMgr::onOutfitRename(const LLSD& notification, const LLSD& response)
+{
+	S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
+	if (option != 0) return; // canceled
+
+	std::string outfit_name = response["new_name"].asString();
+	LLStringUtil::trim(outfit_name);
+	if (!outfit_name.empty())
+	{
+		LLUUID cat_id = notification["payload"]["cat_id"].asUUID();
+		rename_category(&gInventory, cat_id, outfit_name);
+	}
+}
+
+void LLAppearanceMgr::setOutfitLocked(bool locked)
+{
+	if (mOutfitLocked == locked)
+	{
+		return;
+	}
+
+	mOutfitLocked = locked;
+	if (locked)
+	{
+		mUnlockOutfitTimer->reset();
+		mUnlockOutfitTimer->start();
+	}
+	else
+	{
+		mUnlockOutfitTimer->stop();
+	}
+
+	LLOutfitObserver::instance().notifyOutfitLockChanged();
+}
+
+void LLAppearanceMgr::addCategoryToCurrentOutfit(const LLUUID& cat_id)
+{
+	LLViewerInventoryCategory* cat = gInventory.getCategory(cat_id);
+	wearInventoryCategory(cat, false, true);
+}
+
+void LLAppearanceMgr::takeOffOutfit(const LLUUID& cat_id)
+{
+	LLInventoryModel::cat_array_t cats;
+	LLInventoryModel::item_array_t items;
+	LLFindWearablesEx collector(/*is_worn=*/ true, /*include_body_parts=*/ false);
+
+	gInventory.collectDescendentsIf(cat_id, cats, items, FALSE, collector);
+
+	LLInventoryModel::item_array_t::const_iterator it = items.begin();
+	const LLInventoryModel::item_array_t::const_iterator it_end = items.end();
+	uuid_vec_t uuids_to_remove;
+	for( ; it_end != it; ++it)
+	{
+		LLViewerInventoryItem* item = *it;
+		uuids_to_remove.push_back(item->getUUID());
+	}
+	removeItemsFromAvatar(uuids_to_remove);
+
+	// deactivate all gestures in the outfit folder
+	LLInventoryModel::item_array_t gest_items;
+	getDescendentsOfAssetType(cat_id, gest_items, LLAssetType::AT_GESTURE);
+	for(S32 i = 0; i  < gest_items.size(); ++i)
+	{
+		LLViewerInventoryItem *gest_item = gest_items[i];
+		if ( LLGestureMgr::instance().isGestureActive( gest_item->getLinkedUUID()) )
+		{
+			LLGestureMgr::instance().deactivateGesture( gest_item->getLinkedUUID() );
+		}
+	}
+}
+
+// Create a copy of src_id + contents as a subfolder of dst_id.
+void LLAppearanceMgr::shallowCopyCategory(const LLUUID& src_id, const LLUUID& dst_id,
+											  LLPointer<LLInventoryCallback> cb)
+{
+	LLInventoryCategory *src_cat = gInventory.getCategory(src_id);
+	if (!src_cat)
+	{
+		LL_WARNS() << "folder not found for src " << src_id.asString() << LL_ENDL;
+		return;
+	}
+	LL_INFOS() << "starting, src_id " << src_id << " name " << src_cat->getName() << " dst_id " << dst_id << LL_ENDL;
+	LLUUID parent_id = dst_id;
+	if(parent_id.isNull())
+	{
+		parent_id = gInventory.getRootFolderID();
+	}
+	LLUUID subfolder_id = gInventory.createNewCategory( parent_id,
+														LLFolderType::FT_NONE,
+														src_cat->getName());
+	shallowCopyCategoryContents(src_id, subfolder_id, cb);
+
+	gInventory.notifyObservers();
+}
+
+void LLAppearanceMgr::slamCategoryLinks(const LLUUID& src_id, const LLUUID& dst_id,
+										bool include_folder_links, LLPointer<LLInventoryCallback> cb)
+{
+	LLInventoryModel::cat_array_t* cats;
+	LLInventoryModel::item_array_t* items;
+	LLSD contents = LLSD::emptyArray();
+	gInventory.getDirectDescendentsOf(src_id, cats, items);
+	LL_INFOS() << "copying " << items->size() << " items" << LL_ENDL;
+	for (LLInventoryModel::item_array_t::const_iterator iter = items->begin();
+		 iter != items->end();
+		 ++iter)
+	{
+		const LLViewerInventoryItem* item = (*iter);
+		switch (item->getActualType())
+		{
+			case LLAssetType::AT_LINK:
+			{
+				LL_DEBUGS("Avatar") << "linking inventory item " << item->getName() << LL_ENDL;
+				//getActualDescription() is used for a new description 
+				//to propagate ordering information saved in descriptions of links
+				LLSD item_contents;
+				item_contents["name"] = item->getName();
+				item_contents["desc"] = item->getActualDescription();
+				item_contents["linked_id"] = item->getLinkedUUID();
+				item_contents["type"] = LLAssetType::AT_LINK; 
+				contents.append(item_contents);
+				break;
+			}
+			case LLAssetType::AT_LINK_FOLDER:
+			{
+				LLViewerInventoryCategory *catp = item->getLinkedCategory();
+				if (catp && include_folder_links)
+				{
+					LL_DEBUGS("Avatar") << "linking inventory folder " << item->getName() << LL_ENDL;
+					LLSD base_contents;
+					base_contents["name"] = catp->getName();
+					base_contents["desc"] = ""; // categories don't have descriptions.
+					base_contents["linked_id"] = catp->getLinkedUUID();
+					base_contents["type"] = LLAssetType::AT_LINK_FOLDER; 
+					contents.append(base_contents);
+				}
+				break;
+			}
+			default:
+			{
+				// Linux refuses to compile unless all possible enums are handled. Really, Linux?
+				break;
+			}
+		}
+	}
+	slam_inventory_folder(dst_id, contents, cb);
+}
+// Copy contents of src_id to dst_id.
+void LLAppearanceMgr::shallowCopyCategoryContents(const LLUUID& src_id, const LLUUID& dst_id,
+													  LLPointer<LLInventoryCallback> cb)
+{
+	LLInventoryModel::cat_array_t* cats;
+	LLInventoryModel::item_array_t* items;
+	gInventory.getDirectDescendentsOf(src_id, cats, items);
+	LL_INFOS() << "copying " << items->size() << " items" << LL_ENDL;
+	LLInventoryObject::const_object_list_t link_array;
+	for (LLInventoryModel::item_array_t::const_iterator iter = items->begin();
+		 iter != items->end();
+		 ++iter)
+	{
+		const LLViewerInventoryItem* item = (*iter);
+		switch (item->getActualType())
+		{
+			case LLAssetType::AT_LINK:
+			{
+				LL_DEBUGS("Avatar") << "linking inventory item " << item->getName() << LL_ENDL;
+				link_array.push_back(LLConstPointer<LLInventoryObject>(item));
+				break;
+			}
+			case LLAssetType::AT_LINK_FOLDER:
+			{
+				LLViewerInventoryCategory *catp = item->getLinkedCategory();
+				// Skip copying outfit links.
+				if (catp && catp->getPreferredType() != LLFolderType::FT_OUTFIT)
+				{
+					LL_DEBUGS("Avatar") << "linking inventory folder " << item->getName() << LL_ENDL;
+					link_array.push_back(LLConstPointer<LLInventoryObject>(item));
+				}
+				break;
+			}
+			case LLAssetType::AT_CLOTHING:
+			case LLAssetType::AT_OBJECT:
+			case LLAssetType::AT_BODYPART:
+			case LLAssetType::AT_GESTURE:
+			{
+				LL_DEBUGS("Avatar") << "copying inventory item " << item->getName() << LL_ENDL;
+				copy_inventory_item(gAgent.getID(),
+									item->getPermissions().getOwner(),
+									item->getUUID(),
+									dst_id,
+									item->getName(),
+									cb);
+				break;
+			}
+			default:
+				// Ignore non-outfit asset types
+				break;
+		}
+	}
+	if (!link_array.empty())
+	{
+		link_inventory_array(dst_id, link_array, cb);
+	}
+}
+
+BOOL LLAppearanceMgr::getCanMakeFolderIntoOutfit(const LLUUID& folder_id)
+{
+	// These are the wearable items that are required for considering this
+	// folder as containing a complete outfit.
+	U32 required_wearables = 0;
+	required_wearables |= 1LL << LLWearableType::WT_SHAPE;
+	required_wearables |= 1LL << LLWearableType::WT_SKIN;
+	required_wearables |= 1LL << LLWearableType::WT_HAIR;
+	required_wearables |= 1LL << LLWearableType::WT_EYES;
+
+	// These are the wearables that the folder actually contains.
+	U32 folder_wearables = 0;
+	LLInventoryModel::cat_array_t* cats;
+	LLInventoryModel::item_array_t* items;
+	gInventory.getDirectDescendentsOf(folder_id, cats, items);
+	for (LLInventoryModel::item_array_t::const_iterator iter = items->begin();
+		 iter != items->end();
+		 ++iter)
+	{
+		const LLViewerInventoryItem* item = (*iter);
+		if (item->isWearableType())
+		{
+			const LLWearableType::EType wearable_type = item->getWearableType();
+			folder_wearables |= 1LL << wearable_type;
+		}
+	}
+
+	// If the folder contains the required wearables, return TRUE.
+	return ((required_wearables & folder_wearables) == required_wearables);
+}
+
+bool LLAppearanceMgr::getCanRemoveOutfit(const LLUUID& outfit_cat_id)
+{
+	// Disallow removing the base outfit.
+	if (outfit_cat_id == getBaseOutfitUUID())
+	{
+		return false;
+	}
+
+	// Check if the outfit folder itself is removable.
+	if (!get_is_category_removable(&gInventory, outfit_cat_id))
+	{
+		return false;
+	}
+
+	// Check for the folder's non-removable descendants.
+	LLFindNonRemovableObjects filter_non_removable;
+	LLInventoryModel::cat_array_t cats;
+	LLInventoryModel::item_array_t items;
+	LLInventoryModel::item_array_t::const_iterator it;
+	gInventory.collectDescendentsIf(outfit_cat_id, cats, items, false, filter_non_removable);
+	if (!cats.empty() || !items.empty())
+	{
+		return false;
+	}
+
+	return true;
+}
+
+// static
+bool LLAppearanceMgr::getCanRemoveFromCOF(const LLUUID& outfit_cat_id)
+{
+	if (gAgentWearables.isCOFChangeInProgress())
+	{
+		return false;
+	}
+
+	LLFindWearablesEx is_worn(/*is_worn=*/ true, /*include_body_parts=*/ false);
+	return gInventory.hasMatchingDirectDescendent(outfit_cat_id, is_worn);
+}
+
+// static
+bool LLAppearanceMgr::getCanAddToCOF(const LLUUID& outfit_cat_id)
+{
+	if (gAgentWearables.isCOFChangeInProgress())
+	{
+		return false;
+	}
+
+	LLInventoryModel::cat_array_t cats;
+	LLInventoryModel::item_array_t items;
+	LLFindWearablesEx not_worn(/*is_worn=*/ false, /*include_body_parts=*/ false);
+	gInventory.collectDescendentsIf(outfit_cat_id,
+		cats,
+		items,
+		LLInventoryModel::EXCLUDE_TRASH,
+		not_worn);
+
+	return items.size() > 0;
+}
+
+bool LLAppearanceMgr::getCanReplaceCOF(const LLUUID& outfit_cat_id)
+{
+	// Don't allow wearing anything while we're changing appearance.
+	if (gAgentWearables.isCOFChangeInProgress())
+	{
+		return false;
+	}
+
+	// Check whether it's the base outfit.
+	if (outfit_cat_id.isNull() || outfit_cat_id == getBaseOutfitUUID())
+	{
+		return false;
+	}
+
+	// Check whether the outfit contains any wearables we aren't wearing already (STORM-702).
+	LLInventoryModel::cat_array_t cats;
+	LLInventoryModel::item_array_t items;
+	LLFindWearablesEx is_worn(/*is_worn=*/ false, /*include_body_parts=*/ true);
+	gInventory.collectDescendentsIf(outfit_cat_id,
+		cats,
+		items,
+		LLInventoryModel::EXCLUDE_TRASH,
+		is_worn);
+
+	return items.size() > 0;
+}
+
+void LLAppearanceMgr::purgeBaseOutfitLink(const LLUUID& category, LLPointer<LLInventoryCallback> cb)
+{
+	LLInventoryModel::cat_array_t cats;
+	LLInventoryModel::item_array_t items;
+	gInventory.collectDescendents(category, cats, items,
+								  LLInventoryModel::EXCLUDE_TRASH);
+	for (S32 i = 0; i < items.size(); ++i)
+	{
+		LLViewerInventoryItem *item = items.at(i);
+		if (item->getActualType() != LLAssetType::AT_LINK_FOLDER)
+			continue;
+		LLViewerInventoryCategory* catp = item->getLinkedCategory();
+		if(catp && catp->getPreferredType() == LLFolderType::FT_OUTFIT)
+		{
+			remove_inventory_item(item->getUUID(), cb);
+		}
+	}
+}
+
+// Keep the last N wearables of each type.  For viewer 2.0, N is 1 for
+// both body parts and clothing items.
+void LLAppearanceMgr::filterWearableItems(
+	LLInventoryModel::item_array_t& items, S32 max_per_type)
+{
+	// Divvy items into arrays by wearable type.
+	std::vector<LLInventoryModel::item_array_t> items_by_type(LLWearableType::WT_COUNT);
+	divvyWearablesByType(items, items_by_type);
+
+	// rebuild items list, retaining the last max_per_type of each array
+	items.clear();
+	for (S32 i=0; i<LLWearableType::WT_COUNT; i++)
+	{
+		S32 size = items_by_type[i].size();
+		if (size <= 0)
+			continue;
+		S32 start_index = llmax(0,size-max_per_type);
+		for (S32 j = start_index; j<size; j++)
+		{
+			items.push_back(items_by_type[i][j]);
+		}
+	}
+}
+
+void LLAppearanceMgr::updateCOF(const LLUUID& category, bool append)
+{
+	LLViewerInventoryCategory *pcat = gInventory.getCategory(category);
+	if (!pcat)
+	{
+		LL_WARNS() << "no category found for id " << category << LL_ENDL;
+		return;
+	}
+	LL_INFOS("Avatar") << self_av_string() << "starting, cat '" << (pcat ? pcat->getName() : "[UNKNOWN]") << "'" << LL_ENDL;
+
+	const LLUUID cof = getCOF();
+
+	// Deactivate currently active gestures in the COF, if replacing outfit
+	if (!append)
+	{
+		LLInventoryModel::item_array_t gest_items;
+		getDescendentsOfAssetType(cof, gest_items, LLAssetType::AT_GESTURE);
+		for(S32 i = 0; i  < gest_items.size(); ++i)
+		{
+			LLViewerInventoryItem *gest_item = gest_items.at(i);
+			if ( LLGestureMgr::instance().isGestureActive( gest_item->getLinkedUUID()) )
+			{
+				LLGestureMgr::instance().deactivateGesture( gest_item->getLinkedUUID() );
+			}
+		}
+	}
+	
+	// Collect and filter descendents to determine new COF contents.
+
+	// - Body parts: always include COF contents as a fallback in case any
+	// required parts are missing.
+	// Preserve body parts from COF if appending.
+	LLInventoryModel::item_array_t body_items;
+	getDescendentsOfAssetType(cof, body_items, LLAssetType::AT_BODYPART);
+	getDescendentsOfAssetType(category, body_items, LLAssetType::AT_BODYPART);
+	if (append)
+		reverse(body_items.begin(), body_items.end());
+	// Reduce body items to max of one per type.
+	removeDuplicateItems(body_items);
+	filterWearableItems(body_items, 1);
+
+	// - Wearables: include COF contents only if appending.
+	LLInventoryModel::item_array_t wear_items;
+	if (append)
+		getDescendentsOfAssetType(cof, wear_items, LLAssetType::AT_CLOTHING);
+	getDescendentsOfAssetType(category, wear_items, LLAssetType::AT_CLOTHING);
+	// Reduce wearables to max of one per type.
+	removeDuplicateItems(wear_items);
+	filterWearableItems(wear_items, LLAgentWearables::MAX_CLOTHING_PER_TYPE);
+
+	// - Attachments: include COF contents only if appending.
+	LLInventoryModel::item_array_t obj_items;
+	if (append)
+		getDescendentsOfAssetType(cof, obj_items, LLAssetType::AT_OBJECT);
+	getDescendentsOfAssetType(category, obj_items, LLAssetType::AT_OBJECT);
+	removeDuplicateItems(obj_items);
+
+	// - Gestures: include COF contents only if appending.
+	LLInventoryModel::item_array_t gest_items;
+	if (append)
+		getDescendentsOfAssetType(cof, gest_items, LLAssetType::AT_GESTURE);
+	getDescendentsOfAssetType(category, gest_items, LLAssetType::AT_GESTURE);
+	removeDuplicateItems(gest_items);
+	
+	// Create links to new COF contents.
+	LLInventoryModel::item_array_t all_items;
+	std::copy(body_items.begin(), body_items.end(), std::back_inserter(all_items));
+	std::copy(wear_items.begin(), wear_items.end(), std::back_inserter(all_items));
+	std::copy(obj_items.begin(), obj_items.end(), std::back_inserter(all_items));
+	std::copy(gest_items.begin(), gest_items.end(), std::back_inserter(all_items));
+
+	// Find any wearables that need description set to enforce ordering.
+	desc_map_t desc_map;
+	getWearableOrderingDescUpdates(wear_items, desc_map);
+
+	// Will link all the above items.
+	// link_waiter enforce flags are false because we've already fixed everything up in updateCOF().
+	LLPointer<LLInventoryCallback> link_waiter = new LLUpdateAppearanceOnDestroy(false,false);
+	LLSD contents = LLSD::emptyArray();
+
+	for (LLInventoryModel::item_array_t::const_iterator it = all_items.begin();
+		 it != all_items.end(); ++it)
+	{
+		LLSD item_contents;
+		LLInventoryItem *item = *it;
+
+		std::string desc;
+		desc_map_t::const_iterator desc_iter = desc_map.find(item->getUUID());
+		if (desc_iter != desc_map.end())
+		{
+			desc = desc_iter->second;
+			LL_DEBUGS("Avatar") << item->getName() << " overriding desc to: " << desc
+								<< " (was: " << item->getActualDescription() << ")" << LL_ENDL;
+		}
+		else
+		{
+			desc = item->getActualDescription();
+		}
+
+		item_contents["name"] = item->getName();
+		item_contents["desc"] = desc;
+		item_contents["linked_id"] = item->getLinkedUUID();
+		item_contents["type"] = LLAssetType::AT_LINK; 
+		contents.append(item_contents);
+	}
+	const LLUUID& base_id = append ? getBaseOutfitUUID() : category;
+	LLViewerInventoryCategory *base_cat = gInventory.getCategory(base_id);
+	if (base_cat)
+	{
+		LLSD base_contents;
+		base_contents["name"] = base_cat->getName();
+		base_contents["desc"] = "";
+		base_contents["linked_id"] = base_cat->getLinkedUUID();
+		base_contents["type"] = LLAssetType::AT_LINK_FOLDER; 
+		contents.append(base_contents);
+	}
+	if (gSavedSettings.getBOOL("DebugAvatarAppearanceMessage"))
+	{
+		dump_sequential_xml(gAgentAvatarp->getFullname() + "_slam_request", contents);
+	}
+	slam_inventory_folder(getCOF(), contents, link_waiter);
+
+	LL_DEBUGS("Avatar") << self_av_string() << "waiting for LLUpdateAppearanceOnDestroy" << LL_ENDL;
+}
+
+void LLAppearanceMgr::updatePanelOutfitName(const std::string& name)
+{
+	LLSidepanelAppearance* panel_appearance =
+		dynamic_cast<LLSidepanelAppearance *>(LLFloaterSidePanelContainer::getPanel("appearance"));
+	if (panel_appearance)
+	{
+		panel_appearance->refreshCurrentOutfitName(name);
+	}
+}
+
+void LLAppearanceMgr::createBaseOutfitLink(const LLUUID& category, LLPointer<LLInventoryCallback> link_waiter)
+{
+	const LLUUID cof = getCOF();
+	LLViewerInventoryCategory* catp = gInventory.getCategory(category);
+	std::string new_outfit_name = "";
+
+	purgeBaseOutfitLink(cof, link_waiter);
+
+	if (catp && catp->getPreferredType() == LLFolderType::FT_OUTFIT)
+	{
+		link_inventory_object(cof, catp, link_waiter);
+		new_outfit_name = catp->getName();
+	}
+	
+	updatePanelOutfitName(new_outfit_name);
+}
+
+void LLAppearanceMgr::updateAgentWearables(LLWearableHoldingPattern* holder)
+{
+	LL_DEBUGS("Avatar") << "updateAgentWearables()" << LL_ENDL;
+	LLInventoryItem::item_array_t items;
+	std::vector< LLViewerWearable* > wearables;
+	wearables.reserve(32);
+
+	// For each wearable type, find the wearables of that type.
+	for( S32 i = 0; i < LLWearableType::WT_COUNT; i++ )
+	{
+		for (LLWearableHoldingPattern::found_list_t::iterator iter = holder->getFoundList().begin();
+			 iter != holder->getFoundList().end(); ++iter)
+		{
+			LLFoundData& data = *iter;
+			LLViewerWearable* wearable = data.mWearable;
+			if( wearable && ((S32)wearable->getType() == i) )
+			{
+				LLViewerInventoryItem* item = (LLViewerInventoryItem*)gInventory.getItem(data.mItemID);
+				if( item && (item->getAssetUUID() == wearable->getAssetID()) )
+				{
+					items.push_back(item);
+					wearables.push_back(wearable);
+				}
+			}
+		}
+	}
+
+	if(wearables.size() > 0)
+	{
+		gAgentWearables.setWearableOutfit(items, wearables);
+	}
+}
+
+S32 LLAppearanceMgr::countActiveHoldingPatterns()
+{
+	return LLWearableHoldingPattern::countActive();
+}
+
+static void remove_non_link_items(LLInventoryModel::item_array_t &items)
+{
+	LLInventoryModel::item_array_t pruned_items;
+	for (LLInventoryModel::item_array_t::const_iterator iter = items.begin();
+		 iter != items.end();
+		 ++iter)
+	{
+ 		const LLViewerInventoryItem *item = (*iter);
+		if (item && item->getIsLinkType())
+		{
+			pruned_items.push_back((*iter));
+		}
+	}
+	items = pruned_items;
+}
+
+//a predicate for sorting inventory items by actual descriptions
+bool sort_by_actual_description(const LLInventoryItem* item1, const LLInventoryItem* item2)
+{
+	if (!item1 || !item2) 
+	{
+		LL_WARNS() << "either item1 or item2 is NULL" << LL_ENDL;
+		return true;
+	}
+
+	return item1->getActualDescription() < item2->getActualDescription();
+}
+
+void item_array_diff(LLInventoryModel::item_array_t& full_list,
+					 LLInventoryModel::item_array_t& keep_list,
+					 LLInventoryModel::item_array_t& kill_list)
+	
+{
+	for (LLInventoryModel::item_array_t::iterator it = full_list.begin();
+		 it != full_list.end();
+		 ++it)
+	{
+		LLViewerInventoryItem *item = *it;
+		if (std::find(keep_list.begin(), keep_list.end(), item) == keep_list.end())
+		{
+			kill_list.push_back(item);
+		}
+	}
+}
+
+S32 LLAppearanceMgr::findExcessOrDuplicateItems(const LLUUID& cat_id,
+												 LLAssetType::EType type,
+												 S32 max_items,
+												 LLInventoryObject::object_list_t& items_to_kill)
+{
+	S32 to_kill_count = 0;
+
+	LLInventoryModel::item_array_t items;
+	getDescendentsOfAssetType(cat_id, items, type);
+	LLInventoryModel::item_array_t curr_items = items;
+	removeDuplicateItems(items);
+	if (max_items > 0)
+	{
+		filterWearableItems(items, max_items);
+	}
+	LLInventoryModel::item_array_t kill_items;
+	item_array_diff(curr_items,items,kill_items);
+	for (LLInventoryModel::item_array_t::iterator it = kill_items.begin();
+		 it != kill_items.end();
+		 ++it)
+	{
+		items_to_kill.push_back(LLPointer<LLInventoryObject>(*it));
+		to_kill_count++;
+	}
+	return to_kill_count;
+}
+	
+
+void LLAppearanceMgr::findAllExcessOrDuplicateItems(const LLUUID& cat_id,
+													LLInventoryObject::object_list_t& items_to_kill)
+{
+	findExcessOrDuplicateItems(cat_id,LLAssetType::AT_BODYPART,
+							   1, items_to_kill);
+	findExcessOrDuplicateItems(cat_id,LLAssetType::AT_CLOTHING,
+							   LLAgentWearables::MAX_CLOTHING_PER_TYPE, items_to_kill);
+	findExcessOrDuplicateItems(cat_id,LLAssetType::AT_OBJECT,
+							   -1, items_to_kill);
+}
+
+void LLAppearanceMgr::enforceCOFItemRestrictions(LLPointer<LLInventoryCallback> cb)
+{
+	LLInventoryObject::object_list_t items_to_kill;
+	findAllExcessOrDuplicateItems(getCOF(), items_to_kill);
+	if (items_to_kill.size()>0)
+	{
+		// Remove duplicate or excess wearables. Should normally be enforced at the UI level, but
+		// this should catch anything that gets through.
+		remove_inventory_items(items_to_kill, cb);
+	}
+}
+
+void LLAppearanceMgr::updateAppearanceFromCOF(bool enforce_item_restrictions,
+											  bool enforce_ordering,
+											  nullary_func_t post_update_func)
+{
+	if (mIsInUpdateAppearanceFromCOF)
+	{
+		LL_WARNS() << "Called updateAppearanceFromCOF inside updateAppearanceFromCOF, skipping" << LL_ENDL;
+		return;
+	}
+
+	LL_DEBUGS("Avatar") << self_av_string() << "starting" << LL_ENDL;
+
+	if (enforce_item_restrictions)
+	{
+		// The point here is just to call
+		// updateAppearanceFromCOF() again after excess items
+		// have been removed. That time we will set
+		// enforce_item_restrictions to false so we don't get
+		// caught in a perpetual loop.
+		LLPointer<LLInventoryCallback> cb(
+			new LLUpdateAppearanceOnDestroy(false, enforce_ordering, post_update_func));
+		enforceCOFItemRestrictions(cb);
+		return;
+	}
+
+	if (enforce_ordering)
+	{
+		//checking integrity of the COF in terms of ordering of wearables, 
+		//checking and updating links' descriptions of wearables in the COF (before analyzed for "dirty" state)
+
+		// As with enforce_item_restrictions handling above, we want
+		// to wait for the update callbacks, then (finally!) call
+		// updateAppearanceFromCOF() with no additional COF munging needed.
+		LLPointer<LLInventoryCallback> cb(
+			new LLUpdateAppearanceOnDestroy(false, false, post_update_func));
+		updateClothingOrderingInfo(LLUUID::null, cb);
+		return;
+	}
+
+	if (!validateClothingOrderingInfo())
+	{
+		LL_WARNS() << "Clothing ordering error" << LL_ENDL;
+	}
+
+	BoolSetter setIsInUpdateAppearanceFromCOF(mIsInUpdateAppearanceFromCOF);
+	selfStartPhase("update_appearance_from_cof");
+
+	// update dirty flag to see if the state of the COF matches
+	// the saved outfit stored as a folder link
+	updateIsDirty();
+
+	// Send server request for appearance update
+	if (gAgent.getRegion() && gAgent.getRegion()->getCentralBakeVersion())
+	{
+		requestServerAppearanceUpdate();
+	}
+
+	LLUUID current_outfit_id = getCOF();
+
+	// Find all the wearables that are in the COF's subtree.
+	LL_DEBUGS() << "LLAppearanceMgr::updateFromCOF()" << LL_ENDL;
+	LLInventoryModel::item_array_t wear_items;
+	LLInventoryModel::item_array_t obj_items;
+	LLInventoryModel::item_array_t gest_items;
+	getUserDescendents(current_outfit_id, wear_items, obj_items, gest_items);
+	// Get rid of non-links in case somehow the COF was corrupted.
+	remove_non_link_items(wear_items);
+	remove_non_link_items(obj_items);
+	remove_non_link_items(gest_items);
+
+	dumpItemArray(wear_items,"asset_dump: wear_item");
+	dumpItemArray(obj_items,"asset_dump: obj_item");
+
+	LLViewerInventoryCategory *cof = gInventory.getCategory(current_outfit_id);
+	if (!gInventory.isCategoryComplete(current_outfit_id))
+	{
+		LL_WARNS() << "COF info is not complete. Version " << cof->getVersion()
+				<< " descendent_count " << cof->getDescendentCount()
+				<< " viewer desc count " << cof->getViewerDescendentCount() << LL_ENDL;
+	}
+	if(!wear_items.size())
+	{
+		LLNotificationsUtil::add("CouldNotPutOnOutfit");
+		return;
+	}
+
+	//preparing the list of wearables in the correct order for LLAgentWearables
+	sortItemsByActualDescription(wear_items);
+
+
+	LL_DEBUGS("Avatar") << "HP block starts" << LL_ENDL;
+	LLTimer hp_block_timer;
+	LLWearableHoldingPattern* holder = new LLWearableHoldingPattern;
+
+	holder->setObjItems(obj_items);
+	holder->setGestItems(gest_items);
+		
+	// Note: can't do normal iteration, because if all the
+	// wearables can be resolved immediately, then the
+	// callback will be called (and this object deleted)
+	// before the final getNextData().
+
+	for(S32 i = 0; i  < wear_items.size(); ++i)
+	{
+		LLViewerInventoryItem *item = wear_items.at(i);
+		LLViewerInventoryItem *linked_item = item ? item->getLinkedItem() : NULL;
+
+		// Fault injection: use debug setting to test asset 
+		// fetch failures (should be replaced by new defaults in
+		// lost&found).
+		U32 skip_type = gSavedSettings.getU32("ForceAssetFail");
+
+		if (item && item->getIsLinkType() && linked_item)
+		{
+			LLFoundData found(linked_item->getUUID(),
+							  linked_item->getAssetUUID(),
+							  linked_item->getName(),
+							  linked_item->getType(),
+							  linked_item->isWearableType() ? linked_item->getWearableType() : LLWearableType::WT_INVALID
+				);
+
+			if (skip_type != LLWearableType::WT_INVALID && skip_type == found.mWearableType)
+			{
+				found.mAssetID.generate(); // Replace with new UUID, guaranteed not to exist in DB
+			}
+			//pushing back, not front, to preserve order of wearables for LLAgentWearables
+			holder->getFoundList().push_back(found);
+		}
+		else
+		{
+			if (!item)
+			{
+				LL_WARNS() << "Attempt to wear a null item " << LL_ENDL;
+			}
+			else if (!linked_item)
+			{
+				LL_WARNS() << "Attempt to wear a broken link [ name:" << item->getName() << " ] " << LL_ENDL;
+			}
+		}
+	}
+
+	selfStartPhase("get_wearables_2");
+
+	for (LLWearableHoldingPattern::found_list_t::iterator it = holder->getFoundList().begin();
+		 it != holder->getFoundList().end(); ++it)
+	{
+		LLFoundData& found = *it;
+
+		LL_DEBUGS() << self_av_string() << "waiting for onWearableAssetFetch callback, asset " << found.mAssetID.asString() << LL_ENDL;
+
+		// Fetch the wearables about to be worn.
+		LLWearableList::instance().getAsset(found.mAssetID,
+											found.mName,
+											gAgentAvatarp,
+											found.mAssetType,
+											onWearableAssetFetch,
+											(void*)holder);
+
+	}
+
+	holder->resetTime(gSavedSettings.getF32("MaxWearableWaitTime"));
+	if (!holder->pollFetchCompletion())
+	{
+		doOnIdleRepeating(boost::bind(&LLWearableHoldingPattern::pollFetchCompletion,holder));
+	}
+	post_update_func();
+
+	LL_DEBUGS("Avatar") << "HP block ends, elapsed " << hp_block_timer.getElapsedTimeF32() << LL_ENDL;
+}
+
+void LLAppearanceMgr::getDescendentsOfAssetType(const LLUUID& category,
+													LLInventoryModel::item_array_t& items,
+													LLAssetType::EType type)
+{
+	LLInventoryModel::cat_array_t cats;
+	LLIsType is_of_type(type);
+	gInventory.collectDescendentsIf(category,
+									cats,
+									items,
+									LLInventoryModel::EXCLUDE_TRASH,
+									is_of_type);
+}
+
+void LLAppearanceMgr::getUserDescendents(const LLUUID& category, 
+											 LLInventoryModel::item_array_t& wear_items,
+											 LLInventoryModel::item_array_t& obj_items,
+											 LLInventoryModel::item_array_t& gest_items)
+{
+	LLInventoryModel::cat_array_t wear_cats;
+	LLFindWearables is_wearable;
+	gInventory.collectDescendentsIf(category,
+									wear_cats,
+									wear_items,
+									LLInventoryModel::EXCLUDE_TRASH,
+									is_wearable);
+
+	LLInventoryModel::cat_array_t obj_cats;
+	LLIsType is_object( LLAssetType::AT_OBJECT );
+	gInventory.collectDescendentsIf(category,
+									obj_cats,
+									obj_items,
+									LLInventoryModel::EXCLUDE_TRASH,
+									is_object);
+
+	// Find all gestures in this folder
+	LLInventoryModel::cat_array_t gest_cats;
+	LLIsType is_gesture( LLAssetType::AT_GESTURE );
+	gInventory.collectDescendentsIf(category,
+									gest_cats,
+									gest_items,
+									LLInventoryModel::EXCLUDE_TRASH,
+									is_gesture);
+}
+
+void LLAppearanceMgr::wearInventoryCategory(LLInventoryCategory* category, bool copy, bool append)
+{
+	if(!category) return;
+
+	selfClearPhases();
+	selfStartPhase("wear_inventory_category");
+
+	gAgentWearables.notifyLoadingStarted();
+
+	LL_INFOS("Avatar") << self_av_string() << "wearInventoryCategory( " << category->getName()
+			 << " )" << LL_ENDL;
+
+	// If we are copying from library, attempt to use AIS to copy the category.
+	bool ais_ran=false;
+	if (copy && AISCommand::isAPIAvailable())
+	{
+		LLUUID parent_id;
+		parent_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_CLOTHING);
+		if (parent_id.isNull())
+		{
+			parent_id = gInventory.getRootFolderID();
+		}
+
+		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)
+	{
+		selfStartPhase("wear_inventory_category_fetch");
+		callAfterCategoryFetch(category->getUUID(),boost::bind(&LLAppearanceMgr::wearCategoryFinal,
+															   &LLAppearanceMgr::instance(),
+															   category->getUUID(), copy, append));
+	}
+}
+
+S32 LLAppearanceMgr::getActiveCopyOperations() const
+{
+	return LLCallAfterInventoryCopyMgr::getInstanceCount(); 
+}
+
+void LLAppearanceMgr::wearCategoryFinal(LLUUID& cat_id, bool copy_items, bool append)
+{
+	LL_INFOS("Avatar") << self_av_string() << "starting" << LL_ENDL;
+
+	selfStopPhase("wear_inventory_category_fetch");
+	
+	// We now have an outfit ready to be copied to agent inventory. Do
+	// it, and wear that outfit normally.
+	LLInventoryCategory* cat = gInventory.getCategory(cat_id);
+	if(copy_items)
+	{
+		LLInventoryModel::cat_array_t* cats;
+		LLInventoryModel::item_array_t* items;
+		gInventory.getDirectDescendentsOf(cat_id, cats, items);
+		std::string name;
+		if(!cat)
+		{
+			// should never happen.
+			name = "New Outfit";
+		}
+		else
+		{
+			name = cat->getName();
+		}
+		LLViewerInventoryItem* item = NULL;
+		LLInventoryModel::item_array_t::const_iterator it = items->begin();
+		LLInventoryModel::item_array_t::const_iterator end = items->end();
+		LLUUID pid;
+		for(; it < end; ++it)
+		{
+			item = *it;
+			if(item)
+			{
+				if(LLInventoryType::IT_GESTURE == item->getInventoryType())
+				{
+					pid = gInventory.findCategoryUUIDForType(LLFolderType::FT_GESTURE);
+				}
+				else
+				{
+					pid = gInventory.findCategoryUUIDForType(LLFolderType::FT_CLOTHING);
+				}
+				break;
+			}
+		}
+		if(pid.isNull())
+		{
+			pid = gInventory.getRootFolderID();
+		}
+		
+		LLUUID new_cat_id = gInventory.createNewCategory(
+			pid,
+			LLFolderType::FT_NONE,
+			name);
+
+		// Create a CopyMgr that will copy items, manage its own destruction
+		new LLCallAfterInventoryCopyMgr(
+			*items, new_cat_id, std::string("wear_inventory_category_callback"),
+			boost::bind(&LLAppearanceMgr::wearInventoryCategoryOnAvatar,
+						LLAppearanceMgr::getInstance(),
+						gInventory.getCategory(new_cat_id),
+						append));
+
+		// BAP fixes a lag in display of created dir.
+		gInventory.notifyObservers();
+	}
+	else
+	{
+		// Wear the inventory category.
+		LLAppearanceMgr::instance().wearInventoryCategoryOnAvatar(cat, append);
+	}
+}
+
+// *NOTE: hack to get from avatar inventory to avatar
+void LLAppearanceMgr::wearInventoryCategoryOnAvatar( LLInventoryCategory* category, bool append )
+{
+	// Avoid unintentionally overwriting old wearables.  We have to do
+	// this up front to avoid having to deal with the case of multiple
+	// wearables being dirty.
+	if (!category) return;
+
+	if ( !LLInventoryCallbackManager::is_instantiated() )
+	{
+		// shutting down, ignore.
+		return;
+	}
+
+	LL_INFOS("Avatar") << self_av_string() << "wearInventoryCategoryOnAvatar '" << category->getName()
+			 << "'" << LL_ENDL;
+			 	
+	if (gAgentCamera.cameraCustomizeAvatar())
+	{
+		// switching to outfit editor should automagically save any currently edited wearable
+		LLFloaterSidePanelContainer::showPanel("appearance", LLSD().with("type", "edit_outfit"));
+	}
+
+	LLAppearanceMgr::changeOutfit(TRUE, category->getUUID(), append);
+}
+
+// FIXME do we really want to search entire inventory for matching name?
+void LLAppearanceMgr::wearOutfitByName(const std::string& name)
+{
+	LL_INFOS("Avatar") << self_av_string() << "Wearing category " << name << LL_ENDL;
+
+	LLInventoryModel::cat_array_t cat_array;
+	LLInventoryModel::item_array_t item_array;
+	LLNameCategoryCollector has_name(name);
+	gInventory.collectDescendentsIf(gInventory.getRootFolderID(),
+									cat_array,
+									item_array,
+									LLInventoryModel::EXCLUDE_TRASH,
+									has_name);
+	bool copy_items = false;
+	LLInventoryCategory* cat = NULL;
+	if (cat_array.size() > 0)
+	{
+		// Just wear the first one that matches
+		cat = cat_array.at(0);
+	}
+	else
+	{
+		gInventory.collectDescendentsIf(LLUUID::null,
+										cat_array,
+										item_array,
+										LLInventoryModel::EXCLUDE_TRASH,
+										has_name);
+		if(cat_array.size() > 0)
+		{
+			cat = cat_array.at(0);
+			copy_items = true;
+		}
+	}
+
+	if(cat)
+	{
+		LLAppearanceMgr::wearInventoryCategory(cat, copy_items, false);
+	}
+	else
+	{
+		LL_WARNS() << "Couldn't find outfit " <<name<< " in wearOutfitByName()"
+				<< LL_ENDL;
+	}
+}
+
+bool areMatchingWearables(const LLViewerInventoryItem *a, const LLViewerInventoryItem *b)
+{
+	return (a->isWearableType() && b->isWearableType() &&
+			(a->getWearableType() == b->getWearableType()));
+}
+
+class LLDeferredCOFLinkObserver: public LLInventoryObserver
+{
+public:
+	LLDeferredCOFLinkObserver(const LLUUID& item_id, LLPointer<LLInventoryCallback> cb, const std::string& description):
+		mItemID(item_id),
+		mCallback(cb),
+		mDescription(description)
+	{
+	}
+
+	~LLDeferredCOFLinkObserver()
+	{
+	}
+	
+	/* virtual */ void changed(U32 mask)
+	{
+		const LLInventoryItem *item = gInventory.getItem(mItemID);
+		if (item)
+		{
+			gInventory.removeObserver(this);
+			LLAppearanceMgr::instance().addCOFItemLink(item, mCallback, mDescription);
+			delete this;
+		}
+	}
+
+private:
+	const LLUUID mItemID;
+	std::string mDescription;
+	LLPointer<LLInventoryCallback> mCallback;
+};
+
+
+// BAP - note that this runs asynchronously if the item is not already loaded from inventory.
+// Dangerous if caller assumes link will exist after calling the function.
+void LLAppearanceMgr::addCOFItemLink(const LLUUID &item_id,
+									 LLPointer<LLInventoryCallback> cb,
+									 const std::string description)
+{
+	const LLInventoryItem *item = gInventory.getItem(item_id);
+	if (!item)
+	{
+		LLDeferredCOFLinkObserver *observer = new LLDeferredCOFLinkObserver(item_id, cb, description);
+		gInventory.addObserver(observer);
+	}
+	else
+	{
+		addCOFItemLink(item, cb, description);
+	}
+}
+
+void LLAppearanceMgr::addCOFItemLink(const LLInventoryItem *item,
+									 LLPointer<LLInventoryCallback> cb,
+									 const std::string description)
+{
+	const LLViewerInventoryItem *vitem = dynamic_cast<const LLViewerInventoryItem*>(item);
+	if (!vitem)
+	{
+		LL_WARNS() << "not an llviewerinventoryitem, failed" << LL_ENDL;
+		return;
+	}
+
+	gInventory.addChangedMask(LLInventoryObserver::LABEL, vitem->getLinkedUUID());
+
+	LLInventoryModel::cat_array_t cat_array;
+	LLInventoryModel::item_array_t item_array;
+	gInventory.collectDescendents(LLAppearanceMgr::getCOF(),
+								  cat_array,
+								  item_array,
+								  LLInventoryModel::EXCLUDE_TRASH);
+	bool linked_already = false;
+	U32 count = 0;
+	for (S32 i=0; i<item_array.size(); i++)
+	{
+		// Are these links to the same object?
+		const LLViewerInventoryItem* inv_item = item_array.at(i).get();
+		const LLWearableType::EType wearable_type = inv_item->getWearableType();
+
+		const bool is_body_part =    (wearable_type == LLWearableType::WT_SHAPE) 
+								  || (wearable_type == LLWearableType::WT_HAIR) 
+								  || (wearable_type == LLWearableType::WT_EYES)
+								  || (wearable_type == LLWearableType::WT_SKIN);
+
+		if (inv_item->getLinkedUUID() == vitem->getLinkedUUID())
+		{
+			linked_already = true;
+		}
+		// Are these links to different items of the same body part
+		// type? If so, new item will replace old.
+		else if ((vitem->isWearableType()) && (vitem->getWearableType() == wearable_type))
+		{
+			++count;
+			if (is_body_part && inv_item->getIsLinkType()  && (vitem->getWearableType() == wearable_type))
+			{
+				remove_inventory_item(inv_item->getUUID(), cb);
+			}
+			else if (count >= LLAgentWearables::MAX_CLOTHING_PER_TYPE)
+			{
+				// MULTI-WEARABLES: make sure we don't go over MAX_CLOTHING_PER_TYPE
+				remove_inventory_item(inv_item->getUUID(), cb);
+			}
+		}
+	}
+
+	if (!linked_already)
+	{
+		LLViewerInventoryItem *copy_item = new LLViewerInventoryItem;
+		copy_item->copyViewerItem(vitem);
+		copy_item->setDescription(description);
+		link_inventory_object(getCOF(), copy_item, cb);
+	}
+}
+
+LLInventoryModel::item_array_t LLAppearanceMgr::findCOFItemLinks(const LLUUID& item_id)
+{
+
+	LLInventoryModel::item_array_t result;
+	const LLViewerInventoryItem *vitem =
+		dynamic_cast<const LLViewerInventoryItem*>(gInventory.getItem(item_id));
+
+	if (vitem)
+	{
+		LLInventoryModel::cat_array_t cat_array;
+		LLInventoryModel::item_array_t item_array;
+		gInventory.collectDescendents(LLAppearanceMgr::getCOF(),
+									  cat_array,
+									  item_array,
+									  LLInventoryModel::EXCLUDE_TRASH);
+		for (S32 i=0; i<item_array.size(); i++)
+		{
+			const LLViewerInventoryItem* inv_item = item_array.at(i).get();
+			if (inv_item->getLinkedUUID() == vitem->getLinkedUUID())
+			{
+				result.push_back(item_array.at(i));
+			}
+		}
+	}
+	return result;
+}
+
+bool LLAppearanceMgr::isLinkedInCOF(const LLUUID& item_id)
+{
+	LLInventoryModel::item_array_t links = LLAppearanceMgr::instance().findCOFItemLinks(item_id);
+	return links.size() > 0;
+}
+
+void LLAppearanceMgr::removeAllClothesFromAvatar()
+{
+	// Fetch worn clothes (i.e. the ones in COF).
+	LLInventoryModel::item_array_t clothing_items;
+	LLInventoryModel::cat_array_t dummy;
+	LLIsType is_clothing(LLAssetType::AT_CLOTHING);
+	gInventory.collectDescendentsIf(getCOF(),
+									dummy,
+									clothing_items,
+									LLInventoryModel::EXCLUDE_TRASH,
+									is_clothing);
+	uuid_vec_t item_ids;
+	for (LLInventoryModel::item_array_t::iterator it = clothing_items.begin();
+		it != clothing_items.end(); ++it)
+	{
+		item_ids.push_back((*it).get()->getLinkedUUID());
+	}
+
+	// Take them off by removing from COF.
+	removeItemsFromAvatar(item_ids);
+}
+
+void LLAppearanceMgr::removeAllAttachmentsFromAvatar()
+{
+	if (!isAgentAvatarValid()) return;
+
+	LLAgentWearables::llvo_vec_t objects_to_remove;
+	
+	for (LLVOAvatar::attachment_map_t::iterator iter = gAgentAvatarp->mAttachmentPoints.begin(); 
+		 iter != gAgentAvatarp->mAttachmentPoints.end();)
+	{
+		LLVOAvatar::attachment_map_t::iterator curiter = iter++;
+		LLViewerJointAttachment* attachment = curiter->second;
+		for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin();
+			 attachment_iter != attachment->mAttachedObjects.end();
+			 ++attachment_iter)
+		{
+			LLViewerObject *attached_object = (*attachment_iter);
+			if (attached_object)
+			{
+				objects_to_remove.push_back(attached_object);
+			}
+		}
+	}
+	uuid_vec_t ids_to_remove;
+	for (LLAgentWearables::llvo_vec_t::iterator it = objects_to_remove.begin();
+		 it != objects_to_remove.end();
+		 ++it)
+	{
+		ids_to_remove.push_back((*it)->getAttachmentItemID());
+	}
+	removeItemsFromAvatar(ids_to_remove);
+}
+
+void LLAppearanceMgr::removeCOFItemLinks(const LLUUID& item_id, LLPointer<LLInventoryCallback> cb)
+{
+	gInventory.addChangedMask(LLInventoryObserver::LABEL, item_id);
+
+	LLInventoryModel::cat_array_t cat_array;
+	LLInventoryModel::item_array_t item_array;
+	gInventory.collectDescendents(LLAppearanceMgr::getCOF(),
+								  cat_array,
+								  item_array,
+								  LLInventoryModel::EXCLUDE_TRASH);
+	for (S32 i=0; i<item_array.size(); i++)
+	{
+		const LLInventoryItem* item = item_array.at(i).get();
+		if (item->getIsLinkType() && item->getLinkedUUID() == item_id)
+		{
+			bool immediate_delete = false;
+			if (item->getType() == LLAssetType::AT_OBJECT)
+			{
+				immediate_delete = true;
+			}
+			remove_inventory_item(item->getUUID(), cb, immediate_delete);
+		}
+	}
+}
+
+void LLAppearanceMgr::removeCOFLinksOfType(LLWearableType::EType type, LLPointer<LLInventoryCallback> cb)
+{
+	LLFindWearablesOfType filter_wearables_of_type(type);
+	LLInventoryModel::cat_array_t cats;
+	LLInventoryModel::item_array_t items;
+	LLInventoryModel::item_array_t::const_iterator it;
+
+	gInventory.collectDescendentsIf(getCOF(), cats, items, true, filter_wearables_of_type);
+	for (it = items.begin(); it != items.end(); ++it)
+	{
+		const LLViewerInventoryItem* item = *it;
+		if (item->getIsLinkType()) // we must operate on links only
+		{
+			remove_inventory_item(item->getUUID(), cb);
+		}
+	}
+}
+
+bool sort_by_linked_uuid(const LLViewerInventoryItem* item1, const LLViewerInventoryItem* item2)
+{
+	if (!item1 || !item2)
+	{
+		LL_WARNS() << "item1, item2 cannot be null, something is very wrong" << LL_ENDL;
+		return true;
+	}
+
+	return item1->getLinkedUUID() < item2->getLinkedUUID();
+}
+
+void LLAppearanceMgr::updateIsDirty()
+{
+	LLUUID cof = getCOF();
+	LLUUID base_outfit;
+
+	// find base outfit link 
+	const LLViewerInventoryItem* base_outfit_item = getBaseOutfitLink();
+	LLViewerInventoryCategory* catp = NULL;
+	if (base_outfit_item && base_outfit_item->getIsLinkType())
+	{
+		catp = base_outfit_item->getLinkedCategory();
+	}
+	if(catp && catp->getPreferredType() == LLFolderType::FT_OUTFIT)
+	{
+		base_outfit = catp->getUUID();
+	}
+
+	// Set dirty to "false" if no base outfit found to disable "Save"
+	// and leave only "Save As" enabled in My Outfits.
+	mOutfitIsDirty = false;
+
+	if (base_outfit.notNull())
+	{
+		LLIsValidItemLink collector;
+
+		LLInventoryModel::cat_array_t cof_cats;
+		LLInventoryModel::item_array_t cof_items;
+		gInventory.collectDescendentsIf(cof, cof_cats, cof_items,
+									  LLInventoryModel::EXCLUDE_TRASH, collector);
+
+		LLInventoryModel::cat_array_t outfit_cats;
+		LLInventoryModel::item_array_t outfit_items;
+		gInventory.collectDescendentsIf(base_outfit, outfit_cats, outfit_items,
+									  LLInventoryModel::EXCLUDE_TRASH, collector);
+
+		if(outfit_items.size() != cof_items.size())
+		{
+			LL_DEBUGS("Avatar") << "item count different - base " << outfit_items.size() << " cof " << cof_items.size() << LL_ENDL;
+			// Current outfit folder should have one more item than the outfit folder.
+			// this one item is the link back to the outfit folder itself.
+			mOutfitIsDirty = true;
+			return;
+		}
+
+		//"dirty" - also means a difference in linked UUIDs and/or a difference in wearables order (links' descriptions)
+		std::sort(cof_items.begin(), cof_items.end(), sort_by_linked_uuid);
+		std::sort(outfit_items.begin(), outfit_items.end(), sort_by_linked_uuid);
+
+		for (U32 i = 0; i < cof_items.size(); ++i)
+		{
+			LLViewerInventoryItem *item1 = cof_items.at(i);
+			LLViewerInventoryItem *item2 = outfit_items.at(i);
+
+			if (item1->getLinkedUUID() != item2->getLinkedUUID() || 
+				item1->getName() != item2->getName() ||
+				item1->getActualDescription() != item2->getActualDescription())
+			{
+				if (item1->getLinkedUUID() != item2->getLinkedUUID())
+				{
+					LL_DEBUGS("Avatar") << "link id different " << LL_ENDL;
+				}
+				else
+				{
+					if (item1->getName() != item2->getName())
+					{
+						LL_DEBUGS("Avatar") << "name different " << item1->getName() << " " << item2->getName() << LL_ENDL;
+					}
+					if (item1->getActualDescription() != item2->getActualDescription())
+					{
+						LL_DEBUGS("Avatar") << "desc different " << item1->getActualDescription()
+											<< " " << item2->getActualDescription() 
+											<< " names " << item1->getName() << " " << item2->getName() << LL_ENDL;
+					}
+				}
+				mOutfitIsDirty = true;
+				return;
+			}
+		}
+	}
+	llassert(!mOutfitIsDirty);
+	LL_DEBUGS("Avatar") << "clean" << LL_ENDL;
+}
+
+// *HACK: Must match name in Library or agent inventory
+const std::string ROOT_GESTURES_FOLDER = "Gestures";
+const std::string COMMON_GESTURES_FOLDER = "Common Gestures";
+const std::string MALE_GESTURES_FOLDER = "Male Gestures";
+const std::string FEMALE_GESTURES_FOLDER = "Female Gestures";
+const std::string SPEECH_GESTURES_FOLDER = "Speech Gestures";
+const std::string OTHER_GESTURES_FOLDER = "Other Gestures";
+
+void LLAppearanceMgr::copyLibraryGestures()
+{
+	LL_INFOS("Avatar") << self_av_string() << "Copying library gestures" << LL_ENDL;
+
+	// Copy gestures
+	LLUUID lib_gesture_cat_id =
+		gInventory.findLibraryCategoryUUIDForType(LLFolderType::FT_GESTURE,false);
+	if (lib_gesture_cat_id.isNull())
+	{
+		LL_WARNS() << "Unable to copy gestures, source category not found" << LL_ENDL;
+	}
+	LLUUID dst_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_GESTURE);
+
+	std::vector<std::string> gesture_folders_to_copy;
+	gesture_folders_to_copy.push_back(MALE_GESTURES_FOLDER);
+	gesture_folders_to_copy.push_back(FEMALE_GESTURES_FOLDER);
+	gesture_folders_to_copy.push_back(COMMON_GESTURES_FOLDER);
+	gesture_folders_to_copy.push_back(SPEECH_GESTURES_FOLDER);
+	gesture_folders_to_copy.push_back(OTHER_GESTURES_FOLDER);
+
+	for(std::vector<std::string>::iterator it = gesture_folders_to_copy.begin();
+		it != gesture_folders_to_copy.end();
+		++it)
+	{
+		std::string& folder_name = *it;
+
+		LLPointer<LLInventoryCallback> cb(NULL);
+
+		// After copying gestures, activate Common, Other, plus
+		// Male and/or Female, depending upon the initial outfit gender.
+		ESex gender = gAgentAvatarp->getSex();
+
+		std::string activate_male_gestures;
+		std::string activate_female_gestures;
+		switch (gender) {
+			case SEX_MALE:
+				activate_male_gestures = MALE_GESTURES_FOLDER;
+				break;
+			case SEX_FEMALE:
+				activate_female_gestures = FEMALE_GESTURES_FOLDER;
+				break;
+			case SEX_BOTH:
+				activate_male_gestures = MALE_GESTURES_FOLDER;
+				activate_female_gestures = FEMALE_GESTURES_FOLDER;
+				break;
+		}
+
+		if (folder_name == activate_male_gestures ||
+			folder_name == activate_female_gestures ||
+			folder_name == COMMON_GESTURES_FOLDER ||
+			folder_name == OTHER_GESTURES_FOLDER)
+		{
+			cb = new LLBoostFuncInventoryCallback(activate_gesture_cb);
+		}
+
+		LLUUID cat_id = findDescendentCategoryIDByName(lib_gesture_cat_id,folder_name);
+		if (cat_id.isNull())
+		{
+			LL_WARNS() << self_av_string() << "failed to find gesture folder for " << folder_name << LL_ENDL;
+		}
+		else
+		{
+			LL_DEBUGS("Avatar") << self_av_string() << "initiating fetch and copy for " << folder_name << " cat_id " << cat_id << LL_ENDL;
+			callAfterCategoryFetch(cat_id,
+								   boost::bind(&LLAppearanceMgr::shallowCopyCategory,
+											   &LLAppearanceMgr::instance(),
+											   cat_id, dst_id, cb));
+		}
+	}
+}
+
+// Handler for anything that's deferred until avatar de-clouds.
+void LLAppearanceMgr::onFirstFullyVisible()
+{
+	gAgentAvatarp->outputRezTiming("Avatar fully loaded");
+	gAgentAvatarp->reportAvatarRezTime();
+	gAgentAvatarp->debugAvatarVisible();
+
+	// If this is the first time we've ever logged in,
+	// then copy default gestures from the library.
+	if (gAgent.isFirstLogin()) {
+		copyLibraryGestures();
+	}
+}
+
+// update "dirty" state - defined outside class to allow for calling
+// after appearance mgr instance has been destroyed.
+void appearance_mgr_update_dirty_state()
+{
+	if (LLAppearanceMgr::instanceExists())
+	{
+		LLAppearanceMgr::getInstance()->updateIsDirty();
+		LLAppearanceMgr::getInstance()->setOutfitLocked(false);
+		gAgentWearables.notifyLoadingFinished();
+	}
+}
+
+void update_base_outfit_after_ordering()
+{
+	LLAppearanceMgr& app_mgr = LLAppearanceMgr::instance();
+	
+	LLPointer<LLInventoryCallback> dirty_state_updater =
+		new LLBoostFuncInventoryCallback(no_op_inventory_func, appearance_mgr_update_dirty_state);
+
+	//COF contains only links so we copy to the Base Outfit only links
+	const LLUUID base_outfit_id = app_mgr.getBaseOutfitUUID();
+	bool copy_folder_links = false;
+	app_mgr.slamCategoryLinks(app_mgr.getCOF(), base_outfit_id, copy_folder_links, dirty_state_updater);
+
+}
+
+// Save COF changes - update the contents of the current base outfit
+// to match the current COF. Fails if no current base outfit is set.
+bool LLAppearanceMgr::updateBaseOutfit()
+{
+	if (isOutfitLocked())
+	{
+		// don't allow modify locked outfit
+		llassert(!isOutfitLocked());
+		return false;
+	}
+
+	setOutfitLocked(true);
+
+	gAgentWearables.notifyLoadingStarted();
+
+	const LLUUID base_outfit_id = getBaseOutfitUUID();
+	if (base_outfit_id.isNull()) return false;
+	LL_DEBUGS("Avatar") << "saving cof to base outfit " << base_outfit_id << LL_ENDL;
+
+	LLPointer<LLInventoryCallback> cb =
+		new LLBoostFuncInventoryCallback(no_op_inventory_func, update_base_outfit_after_ordering);
+	// Really shouldn't be needed unless there's a race condition -
+	// updateAppearanceFromCOF() already calls updateClothingOrderingInfo.
+	updateClothingOrderingInfo(LLUUID::null, cb);
+
+	return true;
+}
+
+void LLAppearanceMgr::divvyWearablesByType(const LLInventoryModel::item_array_t& items, wearables_by_type_t& items_by_type)
+{
+	items_by_type.resize(LLWearableType::WT_COUNT);
+	if (items.empty()) return;
+
+	for (S32 i=0; i<items.size(); i++)
+	{
+		LLViewerInventoryItem *item = items.at(i);
+		if (!item)
+		{
+			LL_WARNS("Appearance") << "NULL item found" << LL_ENDL;
+			continue;
+		}
+		// Ignore non-wearables.
+		if (!item->isWearableType())
+			continue;
+		LLWearableType::EType type = item->getWearableType();
+		if(type < 0 || type >= LLWearableType::WT_COUNT)
+		{
+			LL_WARNS("Appearance") << "Invalid wearable type. Inventory type does not match wearable flag bitfield." << LL_ENDL;
+			continue;
+		}
+		items_by_type[type].push_back(item);
+	}
+}
+
+std::string build_order_string(LLWearableType::EType type, U32 i)
+{
+		std::ostringstream order_num;
+		order_num << ORDER_NUMBER_SEPARATOR << type * 100 + i;
+		return order_num.str();
+}
+
+struct WearablesOrderComparator
+{
+	LOG_CLASS(WearablesOrderComparator);
+	WearablesOrderComparator(const LLWearableType::EType type)
+	{
+		mControlSize = build_order_string(type, 0).size();
+	};
+
+	bool operator()(const LLInventoryItem* item1, const LLInventoryItem* item2)
+	{
+		const std::string& desc1 = item1->getActualDescription();
+		const std::string& desc2 = item2->getActualDescription();
+		
+		bool item1_valid = (desc1.size() == mControlSize) && (ORDER_NUMBER_SEPARATOR == desc1[0]);
+		bool item2_valid = (desc2.size() == mControlSize) && (ORDER_NUMBER_SEPARATOR == desc2[0]);
+
+		if (item1_valid && item2_valid)
+			return desc1 < desc2;
+
+		//we need to sink down invalid items: items with empty descriptions, items with "Broken link" descriptions,
+		//items with ordering information but not for the associated wearables type
+		if (!item1_valid && item2_valid) 
+			return false;
+		else if (item1_valid && !item2_valid)
+			return true;
+
+		return item1->getName() < item2->getName();
+	}
+
+	U32 mControlSize;
+};
+
+void LLAppearanceMgr::getWearableOrderingDescUpdates(LLInventoryModel::item_array_t& wear_items,
+													 desc_map_t& desc_map)
+{
+	wearables_by_type_t items_by_type(LLWearableType::WT_COUNT);
+	divvyWearablesByType(wear_items, items_by_type);
+
+	for (U32 type = LLWearableType::WT_SHIRT; type < LLWearableType::WT_COUNT; type++)
+	{
+		U32 size = items_by_type[type].size();
+		if (!size) continue;
+		
+		//sinking down invalid items which need reordering
+		std::sort(items_by_type[type].begin(), items_by_type[type].end(), WearablesOrderComparator((LLWearableType::EType) type));
+		
+		//requesting updates only for those links which don't have "valid" descriptions
+		for (U32 i = 0; i < size; i++)
+		{
+			LLViewerInventoryItem* item = items_by_type[type][i];
+			if (!item) continue;
+			
+			std::string new_order_str = build_order_string((LLWearableType::EType)type, i);
+			if (new_order_str == item->getActualDescription()) continue;
+			
+			desc_map[item->getUUID()] = new_order_str;
+		}
+	}
+}
+
+bool LLAppearanceMgr::validateClothingOrderingInfo(LLUUID cat_id)
+{
+	// COF is processed if cat_id is not specified
+	if (cat_id.isNull())
+	{
+		cat_id = getCOF();
+	}
+
+	LLInventoryModel::item_array_t wear_items;
+	getDescendentsOfAssetType(cat_id, wear_items, LLAssetType::AT_CLOTHING);
+
+	// Identify items for which desc needs to change.
+	desc_map_t desc_map;
+	getWearableOrderingDescUpdates(wear_items, desc_map);
+
+	for (desc_map_t::const_iterator it = desc_map.begin();
+		 it != desc_map.end(); ++it)
+	{
+		const LLUUID& item_id = it->first;
+		const std::string& new_order_str = it->second;
+		LLViewerInventoryItem *item = gInventory.getItem(item_id);
+		LL_WARNS() << "Order validation fails: " << item->getName()
+				<< " needs to update desc to: " << new_order_str
+				<< " (from: " << item->getActualDescription() << ")" << LL_ENDL;
+	}
+	
+	return desc_map.size() == 0;
+}
+
+void LLAppearanceMgr::updateClothingOrderingInfo(LLUUID cat_id,
+												 LLPointer<LLInventoryCallback> cb)
+{
+	// COF is processed if cat_id is not specified
+	if (cat_id.isNull())
+	{
+		cat_id = getCOF();
+	}
+
+	LLInventoryModel::item_array_t wear_items;
+	getDescendentsOfAssetType(cat_id, wear_items, LLAssetType::AT_CLOTHING);
+
+	// Identify items for which desc needs to change.
+	desc_map_t desc_map;
+	getWearableOrderingDescUpdates(wear_items, desc_map);
+
+	for (desc_map_t::const_iterator it = desc_map.begin();
+		 it != desc_map.end(); ++it)
+	{
+		LLSD updates;
+		const LLUUID& item_id = it->first;
+		const std::string& new_order_str = it->second;
+		LLViewerInventoryItem *item = gInventory.getItem(item_id);
+		LL_DEBUGS("Avatar") << item->getName() << " updating desc to: " << new_order_str
+			<< " (was: " << item->getActualDescription() << ")" << LL_ENDL;
+		updates["desc"] = new_order_str;
+		update_inventory_item(item_id,updates,cb);
+	}
+		
+}
+
+//=========================================================================
+class LLAppearanceMgrHttpHandler : public LLHttpSDHandler
+{
+public:
+	LLAppearanceMgrHttpHandler(const std::string& capabilityURL, LLAppearanceMgr *mgr) :
+		LLHttpSDHandler(capabilityURL),
+		mManager(mgr)
+	{ }
+
+	virtual ~LLAppearanceMgrHttpHandler()
+	{ }
+
+	virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);
+
+protected:
+	virtual void onSuccess(LLCore::HttpResponse * response, LLSD &content);
+	virtual void onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status);
+
+private:
+	static void debugCOF(const LLSD& content);
+
+	LLAppearanceMgr *mManager;
+
+};
+
+//-------------------------------------------------------------------------
+void LLAppearanceMgrHttpHandler::onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response)
+{
+	mManager->decrementInFlightCounter();
+
+	LLHttpSDHandler::onCompleted(handle, response);
+}
+
+void LLAppearanceMgrHttpHandler::onSuccess(LLCore::HttpResponse * response, LLSD &content)
+{
+	if (!content.isMap())
+	{
+		LLCore::HttpStatus status = LLCore::HttpStatus(HTTP_INTERNAL_ERROR, "Malformed response contents");
+		response->setStatus(status);
+		onFailure(response, status);
+		if (gSavedSettings.getBOOL("DebugAvatarAppearanceMessage"))
+		{
+			debugCOF(content);
+		}
+		return;
+	}
+	if (content["success"].asBoolean())
+	{
+		LL_DEBUGS("Avatar") << "succeeded" << LL_ENDL;
+		if (gSavedSettings.getBOOL("DebugAvatarAppearanceMessage"))
+		{
+			dump_sequential_xml(gAgentAvatarp->getFullname() + "_appearance_request_ok", content);
+		}
+	}
+	else
+	{
+		LLCore::HttpStatus status = LLCore::HttpStatus(HTTP_INTERNAL_ERROR, "Non-success response");
+		response->setStatus(status);
+		onFailure(response, status);
+		if (gSavedSettings.getBOOL("DebugAvatarAppearanceMessage"))
+		{
+			debugCOF(content);
+		}
+		return;
+	}
+}
+
+void LLAppearanceMgrHttpHandler::onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status)
+{
+	LL_WARNS("Avatar") << "Appearance Mgr request failed to " << getUri()
+		<< ". Reason code: (" << status.toTerseString() << ") "
+		<< status.toString() << LL_ENDL;
+}
+
+void LLAppearanceMgrHttpHandler::debugCOF(const LLSD& content)
+{
+	dump_sequential_xml(gAgentAvatarp->getFullname() + "_appearance_request_error", content);
+
+	LL_INFOS("Avatar") << "AIS COF, version received: " << content["expected"].asInteger()
+		<< " ================================= " << LL_ENDL;
+	std::set<LLUUID> ais_items, local_items;
+	const LLSD& cof_raw = content["cof_raw"];
+	for (LLSD::array_const_iterator it = cof_raw.beginArray();
+		it != cof_raw.endArray(); ++it)
+	{
+		const LLSD& item = *it;
+		if (item["parent_id"].asUUID() == LLAppearanceMgr::instance().getCOF())
+		{
+			ais_items.insert(item["item_id"].asUUID());
+			if (item["type"].asInteger() == 24) // link
+			{
+				LL_INFOS("Avatar") << "AIS Link: item_id: " << item["item_id"].asUUID()
+					<< " linked_item_id: " << item["asset_id"].asUUID()
+					<< " name: " << item["name"].asString()
+					<< LL_ENDL; 
+			}
+			else if (item["type"].asInteger() == 25) // folder link
+			{
+				LL_INFOS("Avatar") << "AIS Folder link: item_id: " << item["item_id"].asUUID()
+					<< " linked_item_id: " << item["asset_id"].asUUID()
+					<< " name: " << item["name"].asString()
+					<< LL_ENDL; 
+			}
+			else
+			{
+				LL_INFOS("Avatar") << "AIS Other: item_id: " << item["item_id"].asUUID()
+					<< " linked_item_id: " << item["asset_id"].asUUID()
+					<< " name: " << item["name"].asString()
+					<< " type: " << item["type"].asInteger()
+					<< LL_ENDL; 
+			}
+		}
+	}
+	LL_INFOS("Avatar") << LL_ENDL;
+	LL_INFOS("Avatar") << "Local COF, version requested: " << content["observed"].asInteger() 
+		<< " ================================= " << LL_ENDL;
+	LLInventoryModel::cat_array_t cat_array;
+	LLInventoryModel::item_array_t item_array;
+	gInventory.collectDescendents(LLAppearanceMgr::instance().getCOF(),
+		cat_array,item_array,LLInventoryModel::EXCLUDE_TRASH);
+	for (S32 i=0; i<item_array.size(); i++)
+	{
+		const LLViewerInventoryItem* inv_item = item_array.at(i).get();
+		local_items.insert(inv_item->getUUID());
+		LL_INFOS("Avatar") << "LOCAL: item_id: " << inv_item->getUUID()
+			<< " linked_item_id: " << inv_item->getLinkedUUID()
+			<< " name: " << inv_item->getName()
+			<< " parent: " << inv_item->getParentUUID()
+			<< LL_ENDL;
+	}
+	LL_INFOS("Avatar") << " ================================= " << LL_ENDL;
+	S32 local_only = 0, ais_only = 0;
+	for (std::set<LLUUID>::iterator it = local_items.begin(); it != local_items.end(); ++it)
+	{
+		if (ais_items.find(*it) == ais_items.end())
+		{
+			LL_INFOS("Avatar") << "LOCAL ONLY: " << *it << LL_ENDL;
+			local_only++;
+		}
+	}
+	for (std::set<LLUUID>::iterator it = ais_items.begin(); it != ais_items.end(); ++it)
+	{
+		if (local_items.find(*it) == local_items.end())
+		{
+			LL_INFOS("Avatar") << "AIS ONLY: " << *it << LL_ENDL;
+			ais_only++;
+		}
+	}
+	if (local_only==0 && ais_only==0)
+	{
+		LL_INFOS("Avatar") << "COF contents identical, only version numbers differ (req "
+			<< content["observed"].asInteger()
+			<< " rcv " << content["expected"].asInteger()
+			<< ")" << LL_ENDL;
+	}
+}
+
+//=========================================================================
+
+
+LLSD LLAppearanceMgr::dumpCOF() const
+{
+	LLSD links = LLSD::emptyArray();
+	LLMD5 md5;
+	
+	LLInventoryModel::cat_array_t cat_array;
+	LLInventoryModel::item_array_t item_array;
+	gInventory.collectDescendents(getCOF(),cat_array,item_array,LLInventoryModel::EXCLUDE_TRASH);
+	for (S32 i=0; i<item_array.size(); i++)
+	{
+		const LLViewerInventoryItem* inv_item = item_array.at(i).get();
+		LLSD item;
+		LLUUID item_id(inv_item->getUUID());
+		md5.update((unsigned char*)item_id.mData, 16);
+		item["description"] = inv_item->getActualDescription();
+		md5.update(inv_item->getActualDescription());
+		item["asset_type"] = inv_item->getActualType();
+		LLUUID linked_id(inv_item->getLinkedUUID());
+		item["linked_id"] = linked_id;
+		md5.update((unsigned char*)linked_id.mData, 16);
+
+		if (LLAssetType::AT_LINK == inv_item->getActualType())
+		{
+			const LLViewerInventoryItem* linked_item = inv_item->getLinkedItem();
+			if (NULL == linked_item)
+			{
+				LL_WARNS() << "Broken link for item '" << inv_item->getName()
+						<< "' (" << inv_item->getUUID()
+						<< ") during requestServerAppearanceUpdate" << LL_ENDL;
+				continue;
+			}
+			// Some assets may be 'hidden' and show up as null in the viewer.
+			//if (linked_item->getAssetUUID().isNull())
+			//{
+			//	LL_WARNS() << "Broken link (null asset) for item '" << inv_item->getName()
+			//			<< "' (" << inv_item->getUUID()
+			//			<< ") during requestServerAppearanceUpdate" << LL_ENDL;
+			//	continue;
+			//}
+			LLUUID linked_asset_id(linked_item->getAssetUUID());
+			md5.update((unsigned char*)linked_asset_id.mData, 16);
+			U32 flags = linked_item->getFlags();
+			md5.update(boost::lexical_cast<std::string>(flags));
+		}
+		else if (LLAssetType::AT_LINK_FOLDER != inv_item->getActualType())
+		{
+			LL_WARNS() << "Non-link item '" << inv_item->getName()
+					<< "' (" << inv_item->getUUID()
+					<< ") type " << (S32) inv_item->getActualType()
+					<< " during requestServerAppearanceUpdate" << LL_ENDL;
+			continue;
+		}
+		links.append(item);
+	}
+	LLSD result = LLSD::emptyMap();
+	result["cof_contents"] = links;
+	char cof_md5sum[MD5HEX_STR_SIZE];
+	md5.finalize();
+	md5.hex_digest(cof_md5sum);
+	result["cof_md5sum"] = std::string(cof_md5sum);
+	return result;
+}
+
+void LLAppearanceMgr::requestServerAppearanceUpdate()
+{
+
+	if (!testCOFRequestVersion())
+	{
+		// *TODO: LL_LOG message here
+		return;
+	}
+
+	if ((mInFlightCounter > 0) && (mInFlightTimer.hasExpired()))
+	{
+		LL_WARNS("Avatar") << "in flight timer expired, resetting " << LL_ENDL;
+		mInFlightCounter = 0;
+	}
+
+	if (gAgentAvatarp->isEditingAppearance())
+	{
+		LL_WARNS("Avatar") << "Avatar editing appeance, not sending request." << LL_ENDL;
+		// don't send out appearance updates if in appearance editing mode
+		return;
+	}
+
+	if (!gAgent.getRegion())
+	{
+		LL_WARNS("Avatar") << "Region not set, cannot request server appearance update" << LL_ENDL;
+		return;
+	}
+	if (gAgent.getRegion()->getCentralBakeVersion() == 0)
+	{
+		LL_WARNS("Avatar") << "Region does not support baking" << LL_ENDL;
+	}
+	std::string url = gAgent.getRegion()->getCapability("UpdateAvatarAppearance");
+	if (url.empty())
+	{
+		LL_WARNS("Avatar") << "No cap for UpdateAvatarAppearance." << LL_ENDL;
+		return;
+	}
+
+	LLSD postData;
+	S32 cof_version = LLAppearanceMgr::instance().getCOFVersion();
+	if (gSavedSettings.getBOOL("DebugAvatarExperimentalServerAppearanceUpdate"))
+	{
+		postData = LLAppearanceMgr::instance().dumpCOF();
+	}
+	else
+	{
+		postData["cof_version"] = cof_version;
+		if (gSavedSettings.getBOOL("DebugForceAppearanceRequestFailure"))
+		{
+			postData["cof_version"] = cof_version + 999;
+		}
+	}
+	LL_DEBUGS("Avatar") << "request url " << url << " my_cof_version " << cof_version << LL_ENDL;
+
+	LLAppearanceMgrHttpHandler * handler = new LLAppearanceMgrHttpHandler(url, this);
+
+	mInFlightCounter++;
+	mInFlightTimer.setTimerExpirySec(60.0);
+
+	llassert(cof_version >= gAgentAvatarp->mLastUpdateRequestCOFVersion);
+	gAgentAvatarp->mLastUpdateRequestCOFVersion = cof_version;
+
+	LLCore::HttpHandle handle = LLCoreHttpUtil::requestPostWithLLSD(mHttpRequest,
+		mHttpPolicy, mHttpPriority, url,
+		postData, mHttpOptions, mHttpHeaders, handler);
+
+	if (handle == LLCORE_HTTP_HANDLE_INVALID)
+	{
+		delete handler;
+		LLCore::HttpStatus status = mHttpRequest->getStatus();
+		LL_WARNS("Avatar") << "Appearance request post failed Reason " << status.toTerseString()
+			<< " \"" << status.toString() << "\"" << LL_ENDL;
+	}
+}
+
+bool LLAppearanceMgr::testCOFRequestVersion() const
+{
+	// If we have already received an update for this or higher cof version, ignore.
+	S32 cof_version = getCOFVersion();
+	S32 last_rcv = gAgentAvatarp->mLastUpdateReceivedCOFVersion;
+	S32 last_req = gAgentAvatarp->mLastUpdateRequestCOFVersion;
+
+	LL_DEBUGS("Avatar") << "cof_version " << cof_version
+		<< " last_rcv " << last_rcv
+		<< " last_req " << last_req
+		<< " in flight " << mInFlightCounter 
+		<< LL_ENDL;
+	if (cof_version < last_rcv)
+	{
+		LL_DEBUGS("Avatar") << "Have already received update for cof version " << last_rcv
+			<< " will not request for " << cof_version << LL_ENDL;
+		return false;
+	}
+	if (/*mInFlightCounter > 0 &&*/ last_req >= cof_version)
+	{
+		LL_DEBUGS("Avatar") << "Request already in flight for cof version " << last_req
+			<< " will not request for " << cof_version << LL_ENDL;
+		return false;
+	}
+
+	// Actually send the request.
+	LL_DEBUGS("Avatar") << "Will send request for cof_version " << cof_version << LL_ENDL;
+	return true;
+}
+
+bool LLAppearanceMgr::onIdle()
+{
+	if (!LLAppearanceMgr::mActive)
 		return true;
-	}
+	mHttpRequest->update(0L);
 	return false;
 }
-
-
-bool LLAppearanceMgr::moveWearable(LLViewerInventoryItem* item, bool closer_to_body)
-{
-	if (!item || !item->isWearableType()) return false;
-	if (item->getType() != LLAssetType::AT_CLOTHING) return false;
-	if (!gInventory.isObjectDescendentOf(item->getUUID(), getCOF())) return false;
-
-	LLInventoryModel::cat_array_t cats;
-	LLInventoryModel::item_array_t items;
-	LLFindWearablesOfType filter_wearables_of_type(item->getWearableType());
-	gInventory.collectDescendentsIf(getCOF(), cats, items, true, filter_wearables_of_type);
-	if (items.empty()) return false;
-
-	// We assume that the items have valid descriptions.
-	std::sort(items.begin(), items.end(), WearablesOrderComparator(item->getWearableType()));
-
-	if (closer_to_body && items.front() == item) return false;
-	if (!closer_to_body && items.back() == item) return false;
-	
-	LLInventoryModel::item_array_t::iterator it = std::find(items.begin(), items.end(), item);
-	if (items.end() == it) return false;
-
-
-	//swapping descriptions
-	closer_to_body ? --it : ++it;
-	LLViewerInventoryItem* swap_item = *it;
-	if (!swap_item) return false;
-	std::string tmp = swap_item->getActualDescription();
-	swap_item->setDescription(item->getActualDescription());
-	item->setDescription(tmp);
-
-	// LL_DEBUGS("Inventory") << "swap, item "
-	// 					   << ll_pretty_print_sd(item->asLLSD())
-	// 					   << " swap_item "
-	// 					   << ll_pretty_print_sd(swap_item->asLLSD()) << LL_ENDL;
-
-	// FIXME switch to use AISv3 where supported.
-	//items need to be updated on a dataserver
-	item->setComplete(TRUE);
-	item->updateServer(FALSE);
-	gInventory.updateItem(item);
-
-	swap_item->setComplete(TRUE);
-	swap_item->updateServer(FALSE);
-	gInventory.updateItem(swap_item);
-
-	//to cause appearance of the agent to be updated
-	bool result = false;
-	if ((result = gAgentWearables.moveWearable(item, closer_to_body)))
-	{
-		gAgentAvatarp->wearableUpdated(item->getWearableType());
-	}
-
-	setOutfitDirty(true);
-
-	//*TODO do we need to notify observers here in such a way?
-	gInventory.notifyObservers();
-
-	return result;
-}
-
-//static
-void LLAppearanceMgr::sortItemsByActualDescription(LLInventoryModel::item_array_t& items)
-{
-	if (items.size() < 2) return;
-
-	std::sort(items.begin(), items.end(), sort_by_actual_description);
-}
-
-//#define DUMP_CAT_VERBOSE
-
-void LLAppearanceMgr::dumpCat(const LLUUID& cat_id, const std::string& msg)
-{
-	LLInventoryModel::cat_array_t cats;
-	LLInventoryModel::item_array_t items;
-	gInventory.collectDescendents(cat_id, cats, items, LLInventoryModel::EXCLUDE_TRASH);
-
-#ifdef DUMP_CAT_VERBOSE
-	LL_INFOS() << LL_ENDL;
-	LL_INFOS() << str << LL_ENDL;
-	S32 hitcount = 0;
-	for(S32 i=0; i<items.size(); i++)
-	{
-		LLViewerInventoryItem *item = items.get(i);
-		if (item)
-			hitcount++;
-		LL_INFOS() << i <<" "<< item->getName() <<LL_ENDL;
-	}
-#endif
-	LL_INFOS() << msg << " count " << items.size() << LL_ENDL;
-}
-
-void LLAppearanceMgr::dumpItemArray(const LLInventoryModel::item_array_t& items,
-									const std::string& msg)
-{
-	for (S32 i=0; i<items.size(); i++)
-	{
-		LLViewerInventoryItem *item = items.at(i);
-		LLViewerInventoryItem *linked_item = item ? item->getLinkedItem() : NULL;
-		LLUUID asset_id;
-		if (linked_item)
-		{
-			asset_id = linked_item->getAssetUUID();
-		}
-		LL_DEBUGS("Avatar") << self_av_string() << msg << " " << i <<" " << (item ? item->getName() : "(nullitem)") << " " << asset_id.asString() << LL_ENDL;
-	}
-}
-
-LLAppearanceMgr::LLAppearanceMgr():
-	mAttachmentInvLinkEnabled(false),
-	mOutfitIsDirty(false),
-	mOutfitLocked(false),
-	mIsInUpdateAppearanceFromCOF(false),
-	mAppearanceResponder(new RequestAgentUpdateAppearanceResponder)
-{
-	LLOutfitObserver& outfit_observer = LLOutfitObserver::instance();
-
-	// unlock outfit on save operation completed
-	outfit_observer.addCOFSavedCallback(boost::bind(
-			&LLAppearanceMgr::setOutfitLocked, this, false));
-
-	mUnlockOutfitTimer.reset(new LLOutfitUnLockTimer(gSavedSettings.getS32(
-			"OutfitOperationsTimeout")));
-
-	gIdleCallbacks.addFunction(&LLAttachmentsMgr::onIdle,NULL);
-}
-
-LLAppearanceMgr::~LLAppearanceMgr()
-{
-}
-
-void LLAppearanceMgr::setAttachmentInvLinkEnable(bool val)
-{
-	LL_DEBUGS("Avatar") << "setAttachmentInvLinkEnable => " << (int) val << LL_ENDL;
-	mAttachmentInvLinkEnabled = val;
-}
-
-void dumpAttachmentSet(const std::set<LLUUID>& atts, const std::string& msg)
-{
-       LL_INFOS() << msg << LL_ENDL;
-       for (std::set<LLUUID>::const_iterator it = atts.begin();
-               it != atts.end();
-               ++it)
-       {
-               LLUUID item_id = *it;
-               LLViewerInventoryItem *item = gInventory.getItem(item_id);
-               if (item)
-                       LL_INFOS() << "atts " << item->getName() << LL_ENDL;
-               else
-                       LL_INFOS() << "atts " << "UNKNOWN[" << item_id.asString() << "]" << LL_ENDL;
-       }
-       LL_INFOS() << LL_ENDL;
-}
-
-void LLAppearanceMgr::registerAttachment(const LLUUID& item_id)
-{
-	   gInventory.addChangedMask(LLInventoryObserver::LABEL, item_id);
-
-	   if (mAttachmentInvLinkEnabled)
-	   {
-		   // we have to pass do_update = true to call LLAppearanceMgr::updateAppearanceFromCOF.
-		   // it will trigger gAgentWariables.notifyLoadingFinished()
-		   // But it is not acceptable solution. See EXT-7777
-		   if (!isLinkedInCOF(item_id))
-		   {
-			   LLPointer<LLInventoryCallback> cb = new LLUpdateAppearanceOnDestroy();
-			   LLAppearanceMgr::addCOFItemLink(item_id, cb);  // Add COF link for item.
-		   }
-	   }
-	   else
-	   {
-		   //LL_INFOS() << "no link changes, inv link not enabled" << LL_ENDL;
-	   }
-}
-
-void LLAppearanceMgr::unregisterAttachment(const LLUUID& item_id)
-{
-	   gInventory.addChangedMask(LLInventoryObserver::LABEL, item_id);
-
-	   if (mAttachmentInvLinkEnabled)
-	   {
-		   LLAppearanceMgr::removeCOFItemLinks(item_id);
-	   }
-	   else
-	   {
-		   //LL_INFOS() << "no link changes, inv link not enabled" << LL_ENDL;
-	   }
-}
-
-BOOL LLAppearanceMgr::getIsInCOF(const LLUUID& obj_id) const
-{
-	const LLUUID& cof = getCOF();
-	if (obj_id == cof)
-		return TRUE;
-	const LLInventoryObject* obj = gInventory.getObject(obj_id);
-	if (obj && obj->getParentUUID() == cof)
-		return TRUE;
-	return FALSE;
-}
-
-// static
-bool LLAppearanceMgr::isLinkInCOF(const LLUUID& obj_id)
-{
-	const LLUUID& target_id = gInventory.getLinkedItemID(obj_id);
-	LLLinkedItemIDMatches find_links(target_id);
-	return gInventory.hasMatchingDirectDescendent(LLAppearanceMgr::instance().getCOF(), find_links);
-}
-
-BOOL LLAppearanceMgr::getIsProtectedCOFItem(const LLUUID& obj_id) const
-{
-	if (!getIsInCOF(obj_id)) return FALSE;
-
-	// If a non-link somehow ended up in COF, allow deletion.
-	const LLInventoryObject *obj = gInventory.getObject(obj_id);
-	if (obj && !obj->getIsLinkType())
-	{
-		return FALSE;
-	}
-
-	// For now, don't allow direct deletion from the COF.  Instead, force users
-	// to choose "Detach" or "Take Off".
-	return TRUE;
-}
-
-class CallAfterCategoryFetchStage2: public LLInventoryFetchItemsObserver
-{
-public:
-	CallAfterCategoryFetchStage2(const uuid_vec_t& ids,
-								 nullary_func_t callable) :
-		LLInventoryFetchItemsObserver(ids),
-		mCallable(callable)
-	{
-	}
-	~CallAfterCategoryFetchStage2()
-	{
-	}
-	virtual void done()
-	{
-		LL_INFOS() << this << " done with incomplete " << mIncomplete.size()
-				<< " complete " << mComplete.size() <<  " calling callable" << LL_ENDL;
-
-		gInventory.removeObserver(this);
-		doOnIdleOneTime(mCallable);
-		delete this;
-	}
-protected:
-	nullary_func_t mCallable;
-};
-
-class CallAfterCategoryFetchStage1: public LLInventoryFetchDescendentsObserver
-{
-public:
-	CallAfterCategoryFetchStage1(const LLUUID& cat_id, nullary_func_t callable) :
-		LLInventoryFetchDescendentsObserver(cat_id),
-		mCallable(callable)
-	{
-	}
-	~CallAfterCategoryFetchStage1()
-	{
-	}
-	virtual void done()
-	{
-		// What we do here is get the complete information on the
-		// items in the requested category, and set up an observer
-		// that will wait for that to happen.
-		LLInventoryModel::cat_array_t cat_array;
-		LLInventoryModel::item_array_t item_array;
-		gInventory.collectDescendents(mComplete.front(),
-									  cat_array,
-									  item_array,
-									  LLInventoryModel::EXCLUDE_TRASH);
-		S32 count = item_array.size();
-		if(!count)
-		{
-			LL_WARNS() << "Nothing fetched in category " << mComplete.front()
-					<< LL_ENDL;
-			gInventory.removeObserver(this);
-			doOnIdleOneTime(mCallable);
-
-			delete this;
-			return;
-		}
-
-		LL_INFOS() << "stage1 got " << item_array.size() << " items, passing to stage2 " << LL_ENDL;
-		uuid_vec_t ids;
-		for(S32 i = 0; i < count; ++i)
-		{
-			ids.push_back(item_array.at(i)->getUUID());
-		}
-		
-		gInventory.removeObserver(this);
-		
-		// do the fetch
-		CallAfterCategoryFetchStage2 *stage2 = new CallAfterCategoryFetchStage2(ids, mCallable);
-		stage2->startFetch();
-		if(stage2->isFinished())
-		{
-			// everything is already here - call done.
-			stage2->done();
-		}
-		else
-		{
-			// it's all on it's way - add an observer, and the inventory
-			// will call done for us when everything is here.
-			gInventory.addObserver(stage2);
-		}
-		delete this;
-	}
-protected:
-	nullary_func_t mCallable;
-};
-
-void callAfterCategoryFetch(const LLUUID& cat_id, nullary_func_t cb)
-{
-	CallAfterCategoryFetchStage1 *stage1 = new CallAfterCategoryFetchStage1(cat_id, cb);
-	stage1->startFetch();
-	if (stage1->isFinished())
-	{
-		stage1->done();
-	}
-	else
-	{
-		gInventory.addObserver(stage1);
-	}
-}
-
-void wear_multiple(const uuid_vec_t& ids, bool replace)
-{
-	LLPointer<LLInventoryCallback> cb = new LLUpdateAppearanceOnDestroy;
-	
-	bool first = true;
-	uuid_vec_t::const_iterator it;
-	for (it = ids.begin(); it != ids.end(); ++it)
-	{
-		// if replace is requested, the first item worn will replace the current top
-		// item, and others will be added.
-		LLAppearanceMgr::instance().wearItemOnAvatar(*it,false,first && replace,cb);
-		first = false;
-	}
-}
-
-// SLapp for easy-wearing of a stock (library) avatar
-//
-class LLWearFolderHandler : public LLCommandHandler
-{
-public:
-	// not allowed from outside the app
-	LLWearFolderHandler() : LLCommandHandler("wear_folder", UNTRUSTED_BLOCK) { }
-
-	bool handle(const LLSD& tokens, const LLSD& query_map,
-				LLMediaCtrl* web)
-	{
-		LLSD::UUID folder_uuid;
-
-		if (folder_uuid.isNull() && query_map.has("folder_name"))
-		{
-			std::string outfit_folder_name = query_map["folder_name"];
-			folder_uuid = findDescendentCategoryIDByName(
-				gInventory.getLibraryRootFolderID(),
-				outfit_folder_name);	
-		}
-		if (folder_uuid.isNull() && query_map.has("folder_id"))
-		{
-			folder_uuid = query_map["folder_id"].asUUID();
-		}
-		
-		if (folder_uuid.notNull())
-		{
-			LLPointer<LLInventoryCategory> category = new LLInventoryCategory(folder_uuid,
-																			  LLUUID::null,
-																			  LLFolderType::FT_CLOTHING,
-																			  "Quick Appearance");
-			if ( gInventory.getCategory( folder_uuid ) != NULL )
-			{
-				LLAppearanceMgr::getInstance()->wearInventoryCategory(category, true, false);
-				
-				// *TODOw: This may not be necessary if initial outfit is chosen already -- josh
-				gAgent.setOutfitChosen(TRUE);
-			}
-		}
-
-		// release avatar picker keyboard focus
-		gFocusMgr.setKeyboardFocus( NULL );
-
-		return true;
-	}
-};
-
-LLWearFolderHandler gWearFolderHandler;
+
+class LLIncrementCofVersionResponder : public LLHTTPClient::Responder
+{
+	LOG_CLASS(LLIncrementCofVersionResponder);
+public:
+	LLIncrementCofVersionResponder() : LLHTTPClient::Responder()
+	{
+		mRetryPolicy = new LLAdaptiveRetryPolicy(1.0, 16.0, 2.0, 5);
+	}
+
+	virtual ~LLIncrementCofVersionResponder()
+	{
+	}
+
+protected:
+	virtual void httpSuccess()
+	{
+		LL_INFOS() << "Successfully incremented agent's COF." << LL_ENDL;
+		const LLSD& content = getContent();
+		if (!content.isMap())
+		{
+			failureResult(HTTP_INTERNAL_ERROR, "Malformed response contents", content);
+			return;
+		}
+		S32 new_version = content["category"]["version"].asInteger();
+
+		// cof_version should have increased
+		llassert(new_version > gAgentAvatarp->mLastUpdateRequestCOFVersion);
+
+		gAgentAvatarp->mLastUpdateRequestCOFVersion = new_version;
+	}
+
+	virtual void httpFailure()
+	{
+		LL_WARNS("Avatar") << "While attempting to increment the agent's cof we got an error "
+						   << dumpResponse() << LL_ENDL;
+		F32 seconds_to_wait;
+		mRetryPolicy->onFailure(getStatus(), getResponseHeaders());
+		if (mRetryPolicy->shouldRetry(seconds_to_wait))
+		{
+			LL_INFOS() << "retrying" << LL_ENDL;
+			doAfterInterval(boost::bind(&LLAppearanceMgr::incrementCofVersion,
+										LLAppearanceMgr::getInstance(),
+										LLHTTPClient::ResponderPtr(this)),
+										seconds_to_wait);
+		}
+		else
+		{
+			LL_WARNS() << "giving up after too many retries" << LL_ENDL;
+		}
+	}
+
+private:
+	LLPointer<LLHTTPRetryPolicy> mRetryPolicy;
+};
+
+void LLAppearanceMgr::incrementCofVersion(LLHTTPClient::ResponderPtr responder_ptr)
+{
+	// If we don't have a region, report it as an error
+	if (gAgent.getRegion() == NULL)
+	{
+		LL_WARNS() << "Region not set, cannot request cof_version increment" << LL_ENDL;
+		return;
+	}
+
+	std::string url = gAgent.getRegion()->getCapability("IncrementCofVersion");
+	if (url.empty())
+	{
+		LL_WARNS() << "No cap for IncrementCofVersion." << LL_ENDL;
+		return;
+	}
+
+	LL_INFOS() << "Requesting cof_version be incremented via capability to: "
+			<< url << LL_ENDL;
+	LLSD headers;
+	LLSD body = LLSD::emptyMap();
+
+	if (!responder_ptr.get())
+	{
+		responder_ptr = LLHTTPClient::ResponderPtr(new LLIncrementCofVersionResponder());
+	}
+
+	LLHTTPClient::get(url, body, responder_ptr, headers, 30.0f);
+}
+
+U32 LLAppearanceMgr::getNumAttachmentsInCOF()
+{
+	const LLUUID cof = getCOF();
+	LLInventoryModel::item_array_t obj_items;
+	getDescendentsOfAssetType(cof, obj_items, LLAssetType::AT_OBJECT);
+	return obj_items.size();
+}
+
+
+std::string LLAppearanceMgr::getAppearanceServiceURL() const
+{
+	if (gSavedSettings.getString("DebugAvatarAppearanceServiceURLOverride").empty())
+	{
+		return mAppearanceServiceURL;
+	}
+	return gSavedSettings.getString("DebugAvatarAppearanceServiceURLOverride");
+}
+
+void show_created_outfit(LLUUID& folder_id, bool show_panel = true)
+{
+	if (!LLApp::isRunning())
+	{
+		LL_WARNS() << "called during shutdown, skipping" << LL_ENDL;
+		return;
+	}
+	
+	LL_DEBUGS("Avatar") << "called" << LL_ENDL;
+	LLSD key;
+	
+	//EXT-7727. For new accounts inventory callback is created during login process
+	// and may be processed after login process is finished
+	if (show_panel)
+	{
+		LL_DEBUGS("Avatar") << "showing panel" << LL_ENDL;
+		LLFloaterSidePanelContainer::showPanel("appearance", "panel_outfits_inventory", key);
+		
+	}
+	LLOutfitsList *outfits_list =
+		dynamic_cast<LLOutfitsList*>(LLFloaterSidePanelContainer::getPanel("appearance", "outfitslist_tab"));
+	if (outfits_list)
+	{
+		outfits_list->setSelectedOutfitByUUID(folder_id);
+	}
+	
+	LLAppearanceMgr::getInstance()->updateIsDirty();
+	gAgentWearables.notifyLoadingFinished(); // New outfit is saved.
+	LLAppearanceMgr::getInstance()->updatePanelOutfitName("");
+
+	// For SSB, need to update appearance after we add a base outfit
+	// link, since, the COF version has changed. There is a race
+	// condition in initial outfit setup which can lead to rez
+	// failures - SH-3860.
+	LL_DEBUGS("Avatar") << "requesting appearance update after createBaseOutfitLink" << LL_ENDL;
+	LLPointer<LLInventoryCallback> cb = new LLUpdateAppearanceOnDestroy;
+	LLAppearanceMgr::getInstance()->createBaseOutfitLink(folder_id, cb);
+}
+
+void LLAppearanceMgr::onOutfitFolderCreated(const LLUUID& folder_id, bool show_panel)
+{
+	LLPointer<LLInventoryCallback> cb =
+		new LLBoostFuncInventoryCallback(no_op_inventory_func,
+										 boost::bind(&LLAppearanceMgr::onOutfitFolderCreatedAndClothingOrdered,this,folder_id,show_panel));
+	updateClothingOrderingInfo(LLUUID::null, cb);
+}
+
+void LLAppearanceMgr::onOutfitFolderCreatedAndClothingOrdered(const LLUUID& folder_id, bool show_panel)
+{
+	LLPointer<LLInventoryCallback> cb =
+		new LLBoostFuncInventoryCallback(no_op_inventory_func,
+										 boost::bind(show_created_outfit,folder_id,show_panel));
+	bool copy_folder_links = false;
+	slamCategoryLinks(getCOF(), folder_id, copy_folder_links, cb);
+}
+
+void LLAppearanceMgr::makeNewOutfitLinks(const std::string& new_folder_name, bool show_panel)
+{
+	if (!isAgentAvatarValid()) return;
+
+	LL_DEBUGS("Avatar") << "creating new outfit" << LL_ENDL;
+
+	gAgentWearables.notifyLoadingStarted();
+
+	// First, make a folder in the My Outfits directory.
+	const LLUUID parent_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_MY_OUTFITS);
+	if (AISCommand::isAPIAvailable())
+	{
+		// cap-based category creation was buggy until recently. use
+		// existence of AIS as an indicator the fix is present. Does
+		// not actually use AIS to create the category.
+		inventory_func_type func = boost::bind(&LLAppearanceMgr::onOutfitFolderCreated,this,_1,show_panel);
+		LLUUID folder_id = gInventory.createNewCategory(
+			parent_id,
+			LLFolderType::FT_OUTFIT,
+			new_folder_name,
+			func);
+	}
+	else
+	{		
+		LLUUID folder_id = gInventory.createNewCategory(
+			parent_id,
+			LLFolderType::FT_OUTFIT,
+			new_folder_name);
+		onOutfitFolderCreated(folder_id, show_panel);
+	}
+}
+
+void LLAppearanceMgr::wearBaseOutfit()
+{
+	const LLUUID& base_outfit_id = getBaseOutfitUUID();
+	if (base_outfit_id.isNull()) return;
+	
+	updateCOF(base_outfit_id);
+}
+
+void LLAppearanceMgr::removeItemsFromAvatar(const uuid_vec_t& ids_to_remove)
+{
+	if (ids_to_remove.empty())
+	{
+		LL_WARNS() << "called with empty list, nothing to do" << LL_ENDL;
+		return;
+	}
+	LLPointer<LLInventoryCallback> cb = new LLUpdateAppearanceOnDestroy;
+	for (uuid_vec_t::const_iterator it = ids_to_remove.begin(); it != ids_to_remove.end(); ++it)
+	{
+		const LLUUID& id_to_remove = *it;
+		const LLUUID& linked_item_id = gInventory.getLinkedItemID(id_to_remove);
+		removeCOFItemLinks(linked_item_id, cb);
+		addDoomedTempAttachment(linked_item_id);
+	}
+}
+
+void LLAppearanceMgr::removeItemFromAvatar(const LLUUID& id_to_remove)
+{
+	LLUUID linked_item_id = gInventory.getLinkedItemID(id_to_remove);
+	LLPointer<LLInventoryCallback> cb = new LLUpdateAppearanceOnDestroy;
+	removeCOFItemLinks(linked_item_id, cb);
+	addDoomedTempAttachment(linked_item_id);
+}
+
+
+// Adds the given item ID to mDoomedTempAttachmentIDs iff it's a temp attachment
+void LLAppearanceMgr::addDoomedTempAttachment(const LLUUID& id_to_remove)
+{
+	LLViewerObject * attachmentp = gAgentAvatarp->findAttachmentByID(id_to_remove);
+	if (attachmentp &&
+		attachmentp->isTempAttachment())
+	{	// If this is a temp attachment and we want to remove it, record the ID 
+		// so it will be deleted when attachments are synced up with COF
+		mDoomedTempAttachmentIDs.insert(id_to_remove);
+		//LL_INFOS() << "Will remove temp attachment id " << id_to_remove << LL_ENDL;
+	}
+}
+
+// Find AND REMOVES the given UUID from mDoomedTempAttachmentIDs
+bool LLAppearanceMgr::shouldRemoveTempAttachment(const LLUUID& item_id)
+{
+	doomed_temp_attachments_t::iterator iter = mDoomedTempAttachmentIDs.find(item_id);
+	if (iter != mDoomedTempAttachmentIDs.end())
+	{
+		mDoomedTempAttachmentIDs.erase(iter);
+		return true;
+	}
+	return false;
+}
+
+
+bool LLAppearanceMgr::moveWearable(LLViewerInventoryItem* item, bool closer_to_body)
+{
+	if (!item || !item->isWearableType()) return false;
+	if (item->getType() != LLAssetType::AT_CLOTHING) return false;
+	if (!gInventory.isObjectDescendentOf(item->getUUID(), getCOF())) return false;
+
+	LLInventoryModel::cat_array_t cats;
+	LLInventoryModel::item_array_t items;
+	LLFindWearablesOfType filter_wearables_of_type(item->getWearableType());
+	gInventory.collectDescendentsIf(getCOF(), cats, items, true, filter_wearables_of_type);
+	if (items.empty()) return false;
+
+	// We assume that the items have valid descriptions.
+	std::sort(items.begin(), items.end(), WearablesOrderComparator(item->getWearableType()));
+
+	if (closer_to_body && items.front() == item) return false;
+	if (!closer_to_body && items.back() == item) return false;
+	
+	LLInventoryModel::item_array_t::iterator it = std::find(items.begin(), items.end(), item);
+	if (items.end() == it) return false;
+
+
+	//swapping descriptions
+	closer_to_body ? --it : ++it;
+	LLViewerInventoryItem* swap_item = *it;
+	if (!swap_item) return false;
+	std::string tmp = swap_item->getActualDescription();
+	swap_item->setDescription(item->getActualDescription());
+	item->setDescription(tmp);
+
+	// LL_DEBUGS("Inventory") << "swap, item "
+	// 					   << ll_pretty_print_sd(item->asLLSD())
+	// 					   << " swap_item "
+	// 					   << ll_pretty_print_sd(swap_item->asLLSD()) << LL_ENDL;
+
+	// FIXME switch to use AISv3 where supported.
+	//items need to be updated on a dataserver
+	item->setComplete(TRUE);
+	item->updateServer(FALSE);
+	gInventory.updateItem(item);
+
+	swap_item->setComplete(TRUE);
+	swap_item->updateServer(FALSE);
+	gInventory.updateItem(swap_item);
+
+	//to cause appearance of the agent to be updated
+	bool result = false;
+	if ((result = gAgentWearables.moveWearable(item, closer_to_body)))
+	{
+		gAgentAvatarp->wearableUpdated(item->getWearableType());
+	}
+
+	setOutfitDirty(true);
+
+	//*TODO do we need to notify observers here in such a way?
+	gInventory.notifyObservers();
+
+	return result;
+}
+
+//static
+void LLAppearanceMgr::sortItemsByActualDescription(LLInventoryModel::item_array_t& items)
+{
+	if (items.size() < 2) return;
+
+	std::sort(items.begin(), items.end(), sort_by_actual_description);
+}
+
+//#define DUMP_CAT_VERBOSE
+
+void LLAppearanceMgr::dumpCat(const LLUUID& cat_id, const std::string& msg)
+{
+	LLInventoryModel::cat_array_t cats;
+	LLInventoryModel::item_array_t items;
+	gInventory.collectDescendents(cat_id, cats, items, LLInventoryModel::EXCLUDE_TRASH);
+
+#ifdef DUMP_CAT_VERBOSE
+	LL_INFOS() << LL_ENDL;
+	LL_INFOS() << str << LL_ENDL;
+	S32 hitcount = 0;
+	for(S32 i=0; i<items.size(); i++)
+	{
+		LLViewerInventoryItem *item = items.get(i);
+		if (item)
+			hitcount++;
+		LL_INFOS() << i <<" "<< item->getName() <<LL_ENDL;
+	}
+#endif
+	LL_INFOS() << msg << " count " << items.size() << LL_ENDL;
+}
+
+void LLAppearanceMgr::dumpItemArray(const LLInventoryModel::item_array_t& items,
+									const std::string& msg)
+{
+	for (S32 i=0; i<items.size(); i++)
+	{
+		LLViewerInventoryItem *item = items.at(i);
+		LLViewerInventoryItem *linked_item = item ? item->getLinkedItem() : NULL;
+		LLUUID asset_id;
+		if (linked_item)
+		{
+			asset_id = linked_item->getAssetUUID();
+		}
+		LL_DEBUGS("Avatar") << self_av_string() << msg << " " << i <<" " << (item ? item->getName() : "(nullitem)") << " " << asset_id.asString() << LL_ENDL;
+	}
+}
+
+bool LLAppearanceMgr::mActive = true;
+
+LLAppearanceMgr::LLAppearanceMgr():
+	mAttachmentInvLinkEnabled(false),
+	mOutfitIsDirty(false),
+	mOutfitLocked(false),
+	mInFlightCounter(0),
+	mInFlightTimer(),
+	mIsInUpdateAppearanceFromCOF(false),
+	//mAppearanceResponder(new RequestAgentUpdateAppearanceResponder),
+	mHttpRequest(),
+	mHttpHeaders(),
+	mHttpOptions(),
+	mHttpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID),
+	mHttpPriority(0)
+{
+	LLAppCoreHttp & app_core_http(LLAppViewer::instance()->getAppCoreHttp());
+
+	mHttpRequest = LLCore::HttpRequest::ptr_t(new LLCore::HttpRequest());
+	mHttpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false);
+	mHttpOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false);
+	mHttpPolicy = app_core_http.getPolicy(LLAppCoreHttp::AP_AVATAR);
+
+	LLOutfitObserver& outfit_observer = LLOutfitObserver::instance();
+	// unlock outfit on save operation completed
+	outfit_observer.addCOFSavedCallback(boost::bind(
+			&LLAppearanceMgr::setOutfitLocked, this, false));
+
+	mUnlockOutfitTimer.reset(new LLOutfitUnLockTimer(gSavedSettings.getS32(
+			"OutfitOperationsTimeout")));
+
+	gIdleCallbacks.addFunction(&LLAttachmentsMgr::onIdle, NULL);
+	doOnIdleRepeating(boost::bind(&LLAppearanceMgr::onIdle, this));
+}
+
+LLAppearanceMgr::~LLAppearanceMgr()
+{
+	mActive = false;
+}
+
+void LLAppearanceMgr::setAttachmentInvLinkEnable(bool val)
+{
+	LL_DEBUGS("Avatar") << "setAttachmentInvLinkEnable => " << (int) val << LL_ENDL;
+	mAttachmentInvLinkEnabled = val;
+}
+
+void dumpAttachmentSet(const std::set<LLUUID>& atts, const std::string& msg)
+{
+       LL_INFOS() << msg << LL_ENDL;
+       for (std::set<LLUUID>::const_iterator it = atts.begin();
+               it != atts.end();
+               ++it)
+       {
+               LLUUID item_id = *it;
+               LLViewerInventoryItem *item = gInventory.getItem(item_id);
+               if (item)
+                       LL_INFOS() << "atts " << item->getName() << LL_ENDL;
+               else
+                       LL_INFOS() << "atts " << "UNKNOWN[" << item_id.asString() << "]" << LL_ENDL;
+       }
+       LL_INFOS() << LL_ENDL;
+}
+
+void LLAppearanceMgr::registerAttachment(const LLUUID& item_id)
+{
+	   gInventory.addChangedMask(LLInventoryObserver::LABEL, item_id);
+
+	   if (mAttachmentInvLinkEnabled)
+	   {
+		   // we have to pass do_update = true to call LLAppearanceMgr::updateAppearanceFromCOF.
+		   // it will trigger gAgentWariables.notifyLoadingFinished()
+		   // But it is not acceptable solution. See EXT-7777
+		   if (!isLinkedInCOF(item_id))
+		   {
+			   LLPointer<LLInventoryCallback> cb = new LLUpdateAppearanceOnDestroy();
+			   LLAppearanceMgr::addCOFItemLink(item_id, cb);  // Add COF link for item.
+		   }
+	   }
+	   else
+	   {
+		   //LL_INFOS() << "no link changes, inv link not enabled" << LL_ENDL;
+	   }
+}
+
+void LLAppearanceMgr::unregisterAttachment(const LLUUID& item_id)
+{
+	   gInventory.addChangedMask(LLInventoryObserver::LABEL, item_id);
+
+	   if (mAttachmentInvLinkEnabled)
+	   {
+		   LLAppearanceMgr::removeCOFItemLinks(item_id);
+	   }
+	   else
+	   {
+		   //LL_INFOS() << "no link changes, inv link not enabled" << LL_ENDL;
+	   }
+}
+
+BOOL LLAppearanceMgr::getIsInCOF(const LLUUID& obj_id) const
+{
+	const LLUUID& cof = getCOF();
+	if (obj_id == cof)
+		return TRUE;
+	const LLInventoryObject* obj = gInventory.getObject(obj_id);
+	if (obj && obj->getParentUUID() == cof)
+		return TRUE;
+	return FALSE;
+}
+
+// static
+bool LLAppearanceMgr::isLinkInCOF(const LLUUID& obj_id)
+{
+	const LLUUID& target_id = gInventory.getLinkedItemID(obj_id);
+	LLLinkedItemIDMatches find_links(target_id);
+	return gInventory.hasMatchingDirectDescendent(LLAppearanceMgr::instance().getCOF(), find_links);
+}
+
+BOOL LLAppearanceMgr::getIsProtectedCOFItem(const LLUUID& obj_id) const
+{
+	if (!getIsInCOF(obj_id)) return FALSE;
+
+	// If a non-link somehow ended up in COF, allow deletion.
+	const LLInventoryObject *obj = gInventory.getObject(obj_id);
+	if (obj && !obj->getIsLinkType())
+	{
+		return FALSE;
+	}
+
+	// For now, don't allow direct deletion from the COF.  Instead, force users
+	// to choose "Detach" or "Take Off".
+	return TRUE;
+}
+
+class CallAfterCategoryFetchStage2: public LLInventoryFetchItemsObserver
+{
+public:
+	CallAfterCategoryFetchStage2(const uuid_vec_t& ids,
+								 nullary_func_t callable) :
+		LLInventoryFetchItemsObserver(ids),
+		mCallable(callable)
+	{
+	}
+	~CallAfterCategoryFetchStage2()
+	{
+	}
+	virtual void done()
+	{
+		LL_INFOS() << this << " done with incomplete " << mIncomplete.size()
+				<< " complete " << mComplete.size() <<  " calling callable" << LL_ENDL;
+
+		gInventory.removeObserver(this);
+		doOnIdleOneTime(mCallable);
+		delete this;
+	}
+protected:
+	nullary_func_t mCallable;
+};
+
+class CallAfterCategoryFetchStage1: public LLInventoryFetchDescendentsObserver
+{
+public:
+	CallAfterCategoryFetchStage1(const LLUUID& cat_id, nullary_func_t callable) :
+		LLInventoryFetchDescendentsObserver(cat_id),
+		mCallable(callable)
+	{
+	}
+	~CallAfterCategoryFetchStage1()
+	{
+	}
+	virtual void done()
+	{
+		// What we do here is get the complete information on the
+		// items in the requested category, and set up an observer
+		// that will wait for that to happen.
+		LLInventoryModel::cat_array_t cat_array;
+		LLInventoryModel::item_array_t item_array;
+		gInventory.collectDescendents(mComplete.front(),
+									  cat_array,
+									  item_array,
+									  LLInventoryModel::EXCLUDE_TRASH);
+		S32 count = item_array.size();
+		if(!count)
+		{
+			LL_WARNS() << "Nothing fetched in category " << mComplete.front()
+					<< LL_ENDL;
+			gInventory.removeObserver(this);
+			doOnIdleOneTime(mCallable);
+
+			delete this;
+			return;
+		}
+
+		LL_INFOS() << "stage1 got " << item_array.size() << " items, passing to stage2 " << LL_ENDL;
+		uuid_vec_t ids;
+		for(S32 i = 0; i < count; ++i)
+		{
+			ids.push_back(item_array.at(i)->getUUID());
+		}
+		
+		gInventory.removeObserver(this);
+		
+		// do the fetch
+		CallAfterCategoryFetchStage2 *stage2 = new CallAfterCategoryFetchStage2(ids, mCallable);
+		stage2->startFetch();
+		if(stage2->isFinished())
+		{
+			// everything is already here - call done.
+			stage2->done();
+		}
+		else
+		{
+			// it's all on it's way - add an observer, and the inventory
+			// will call done for us when everything is here.
+			gInventory.addObserver(stage2);
+		}
+		delete this;
+	}
+protected:
+	nullary_func_t mCallable;
+};
+
+void callAfterCategoryFetch(const LLUUID& cat_id, nullary_func_t cb)
+{
+	CallAfterCategoryFetchStage1 *stage1 = new CallAfterCategoryFetchStage1(cat_id, cb);
+	stage1->startFetch();
+	if (stage1->isFinished())
+	{
+		stage1->done();
+	}
+	else
+	{
+		gInventory.addObserver(stage1);
+	}
+}
+
+void wear_multiple(const uuid_vec_t& ids, bool replace)
+{
+	LLPointer<LLInventoryCallback> cb = new LLUpdateAppearanceOnDestroy;
+	
+	bool first = true;
+	uuid_vec_t::const_iterator it;
+	for (it = ids.begin(); it != ids.end(); ++it)
+	{
+		// if replace is requested, the first item worn will replace the current top
+		// item, and others will be added.
+		LLAppearanceMgr::instance().wearItemOnAvatar(*it,false,first && replace,cb);
+		first = false;
+	}
+}
+
+// SLapp for easy-wearing of a stock (library) avatar
+//
+class LLWearFolderHandler : public LLCommandHandler
+{
+public:
+	// not allowed from outside the app
+	LLWearFolderHandler() : LLCommandHandler("wear_folder", UNTRUSTED_BLOCK) { }
+
+	bool handle(const LLSD& tokens, const LLSD& query_map,
+				LLMediaCtrl* web)
+	{
+		LLSD::UUID folder_uuid;
+
+		if (folder_uuid.isNull() && query_map.has("folder_name"))
+		{
+			std::string outfit_folder_name = query_map["folder_name"];
+			folder_uuid = findDescendentCategoryIDByName(
+				gInventory.getLibraryRootFolderID(),
+				outfit_folder_name);	
+		}
+		if (folder_uuid.isNull() && query_map.has("folder_id"))
+		{
+			folder_uuid = query_map["folder_id"].asUUID();
+		}
+		
+		if (folder_uuid.notNull())
+		{
+			LLPointer<LLInventoryCategory> category = new LLInventoryCategory(folder_uuid,
+																			  LLUUID::null,
+																			  LLFolderType::FT_CLOTHING,
+																			  "Quick Appearance");
+			if ( gInventory.getCategory( folder_uuid ) != NULL )
+			{
+				LLAppearanceMgr::getInstance()->wearInventoryCategory(category, true, false);
+				
+				// *TODOw: This may not be necessary if initial outfit is chosen already -- josh
+				gAgent.setOutfitChosen(TRUE);
+			}
+		}
+
+		// release avatar picker keyboard focus
+		gFocusMgr.setKeyboardFocus( NULL );
+
+		return true;
+	}
+};
+
+LLWearFolderHandler gWearFolderHandler;
diff --git a/indra/newview/llappearancemgr.h b/indra/newview/llappearancemgr.h
index 7742a19c07..74d4829ed2 100755
--- a/indra/newview/llappearancemgr.h
+++ b/indra/newview/llappearancemgr.h
@@ -225,9 +225,22 @@ public:
 	void setAppearanceServiceURL(const std::string& url) { mAppearanceServiceURL = url; }
 	std::string getAppearanceServiceURL() const;
 
+
+	bool testCOFRequestVersion() const;
+	void LLAppearanceMgr::decrementInFlightCounter()
+	{
+		mInFlightCounter = llmax(mInFlightCounter - 1, 0);
+	}
+
+
 private:
 	std::string		mAppearanceServiceURL;
 	
+	LLCore::HttpRequest::ptr_t		mHttpRequest;
+	LLCore::HttpHeaders::ptr_t		mHttpHeaders;
+	LLCore::HttpOptions::ptr_t		mHttpOptions;
+	LLCore::HttpRequest::policy_t	mHttpPolicy;
+	LLCore::HttpRequest::priority_t	mHttpPriority;
 
 protected:
 	LLAppearanceMgr();
@@ -248,17 +261,20 @@ private:
 
 	static void onOutfitRename(const LLSD& notification, const LLSD& response);
 
+	bool onIdle();
+
 	bool mAttachmentInvLinkEnabled;
 	bool mOutfitIsDirty;
 	bool mIsInUpdateAppearanceFromCOF; // to detect recursive calls.
 
-	LLPointer<RequestAgentUpdateAppearanceResponder> mAppearanceResponder;
-
 	/**
 	 * Lock for blocking operations on outfit until server reply or timeout exceed
 	 * to avoid unsynchronized outfit state or performing duplicate operations.
 	 */
 	bool mOutfitLocked;
+	S32  mInFlightCounter;
+	LLTimer mInFlightTimer;
+	static bool mActive;
 
 	std::auto_ptr<LLOutfitUnLockTimer> mUnlockOutfitTimer;
 
diff --git a/indra/newview/llmaterialmgr.cpp b/indra/newview/llmaterialmgr.cpp
index 81372f10b3..065d763596 100755
--- a/indra/newview/llmaterialmgr.cpp
+++ b/indra/newview/llmaterialmgr.cpp
@@ -660,7 +660,7 @@ void LLMaterialMgr::processGetQueue()
 		LL_DEBUGS("Materials") << "POSTing to region '" << regionp->getName() << "' at '" << capURL << " for " << materialsData.size() << " materials."
 			<< "\ndata: " << ll_pretty_print_sd(materialsData) << LL_ENDL;
 
-		LLCore::HttpHandle handle = LLCoreHttpUtil::requestPutWithLLSD(mHttpRequest, 
+		LLCore::HttpHandle handle = LLCoreHttpUtil::requestPostWithLLSD(mHttpRequest, 
 				mHttpPolicy, mHttpPriority, capURL, 
 				postData, mHttpOptions, mHttpHeaders, handler);
 
diff --git a/indra/newview/llxmlrpctransaction.cpp b/indra/newview/llxmlrpctransaction.cpp
index f7b886b2d2..702d0c3a29 100755
--- a/indra/newview/llxmlrpctransaction.cpp
+++ b/indra/newview/llxmlrpctransaction.cpp
@@ -401,14 +401,6 @@ LLXMLRPCTransaction::Impl::~Impl()
 	{
 		XMLRPC_RequestFree(mResponse, 1);
 	}
-	
-	//if (mRequestText)
-	//{
-	//	XMLRPC_Free(mRequestText);
-	//}
-	
-	//delete mCurlRequest;
-	//mCurlRequest = NULL ;
 }
 
 bool LLXMLRPCTransaction::Impl::process()
-- 
cgit v1.3


From 735364038767694ea29d9b6a168410e6482cc9c2 Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Fri, 27 Mar 2015 17:00:02 -0700
Subject: first set of chnages from code review from Nat

---
 indra/llcorehttp/_httpoprequest.cpp            |  10 +-
 indra/llcorehttp/_httpoprequest.h              |   5 +-
 indra/llcorehttp/_httppolicyglobal.cpp         |   4 +-
 indra/llcorehttp/_httppolicyglobal.h           |   6 +-
 indra/llcorehttp/_httpservice.cpp              |   4 +-
 indra/llcorehttp/_httpservice.h                |   6 +-
 indra/llcorehttp/httpcommon.h                  |  75 +++++++-------
 indra/llcorehttp/httpoptions.cpp               |   8 +-
 indra/llcorehttp/httpoptions.h                 |  90 ++++++++++-------
 indra/llcorehttp/httprequest.cpp               |  10 +-
 indra/llcorehttp/httprequest.h                 |   4 +-
 indra/llmessage/llhttpsdhandler.cpp            |   2 +-
 indra/llmessage/llhttpsdhandler.h              |   4 +-
 indra/newview/llagent.cpp                      |  11 ++-
 indra/newview/llagent.h                        |   4 +-
 indra/newview/llagentlanguage.cpp              |   2 +-
 indra/newview/llappcorehttp.cpp                |   2 +-
 indra/newview/llappearancemgr.cpp              |   6 +-
 indra/newview/llavatarrenderinfoaccountant.cpp | 131 ++++++++++++++++++++++++-
 indra/newview/llavatarrenderinfoaccountant.h   |  10 +-
 indra/newview/llmaterialmgr.cpp                |   4 +-
 21 files changed, 271 insertions(+), 127 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/_httpoprequest.cpp b/indra/llcorehttp/_httpoprequest.cpp
index 48e22468cd..5768fe5a90 100755
--- a/indra/llcorehttp/_httpoprequest.cpp
+++ b/indra/llcorehttp/_httpoprequest.cpp
@@ -115,9 +115,8 @@ namespace LLCore
 {
 
 
-HttpOpRequest::HttpOpRequest(HttpRequest const * const request)
+HttpOpRequest::HttpOpRequest()
 	: HttpOperation(),
-	  mRequest(request),
 	  mProcFlags(0U),
 	  mReqMethod(HOR_GET),
 	  mReqBody(NULL),
@@ -490,13 +489,13 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 	long follow_redirect(1L);
 	long sslPeerV(0L);
 	long sslHostV(0L);
-	long dnsCacheTimeout(15L);
+    long dnsCacheTimeout(-1L);
 
 	if (mReqOptions)
 	{
 		follow_redirect = mReqOptions->getFollowRedirects() ? 1L : 0L;
-		sslPeerV = mReqOptions->getSSLVerifyHost() ? 0L : 1L;
-		sslHostV = mReqOptions->getSSLVerifyHost();
+		sslPeerV = mReqOptions->getSSLVerifyPeer() ? 1L : 0L;
+		sslHostV = mReqOptions->getSSLVerifyHost() ? 2L : 0L;
 		dnsCacheTimeout = mReqOptions->getDNSCacheTimeout();
 	}
 	code = curl_easy_setopt(mCurlHandle, CURLOPT_FOLLOWLOCATION, follow_redirect);
@@ -516,7 +515,6 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 	code = curl_easy_setopt(mCurlHandle, CURLOPT_DNS_CACHE_TIMEOUT, dnsCacheTimeout);
 	check_curl_easy_code(code, CURLOPT_DNS_CACHE_TIMEOUT);
 
-
 	if (gpolicy.mUseLLProxy)
 	{
 		// Use the viewer-based thread-safe API which has a
diff --git a/indra/llcorehttp/_httpoprequest.h b/indra/llcorehttp/_httpoprequest.h
index 7a4b7c189e..e71d1d1edf 100755
--- a/indra/llcorehttp/_httpoprequest.h
+++ b/indra/llcorehttp/_httpoprequest.h
@@ -66,7 +66,7 @@ class HttpOptions;
 class HttpOpRequest : public HttpOperation
 {
 public:
-	HttpOpRequest(HttpRequest const * const request);
+	HttpOpRequest();
 
 protected:
 	virtual ~HttpOpRequest();							// Use release()
@@ -165,11 +165,10 @@ protected:
 	static const unsigned int	PF_SAVE_HEADERS = 0x00000002U;
 	static const unsigned int	PF_USE_RETRY_AFTER = 0x00000004U;
 
-	HttpRequest::policyCallback	mCallbackSSLVerify;
+	HttpRequest::policyCallback_t	mCallbackSSLVerify;
 
 public:
 	// Request data
-	HttpRequest const * const mRequest;
 	EMethod				mReqMethod;
 	std::string			mReqURL;
 	BufferArray *		mReqBody;
diff --git a/indra/llcorehttp/_httppolicyglobal.cpp b/indra/llcorehttp/_httppolicyglobal.cpp
index c4ef38a815..3d0df96ade 100755
--- a/indra/llcorehttp/_httppolicyglobal.cpp
+++ b/indra/llcorehttp/_httppolicyglobal.cpp
@@ -106,7 +106,7 @@ HttpStatus HttpPolicyGlobal::set(HttpRequest::EPolicyOption opt, const std::stri
 	return HttpStatus();
 }
 
-HttpStatus HttpPolicyGlobal::set(HttpRequest::EPolicyOption opt, HttpRequest::policyCallback value)
+HttpStatus HttpPolicyGlobal::set(HttpRequest::EPolicyOption opt, HttpRequest::policyCallback_t value)
 {
 	switch (opt)
 	{
@@ -169,7 +169,7 @@ HttpStatus HttpPolicyGlobal::get(HttpRequest::EPolicyOption opt, std::string * v
 }
 
 
-HttpStatus HttpPolicyGlobal::get(HttpRequest::EPolicyOption opt, HttpRequest::policyCallback * value) const
+HttpStatus HttpPolicyGlobal::get(HttpRequest::EPolicyOption opt, HttpRequest::policyCallback_t * value) const
 {
 	switch (opt)
 	{
diff --git a/indra/llcorehttp/_httppolicyglobal.h b/indra/llcorehttp/_httppolicyglobal.h
index 1696238814..e02da4386a 100755
--- a/indra/llcorehttp/_httppolicyglobal.h
+++ b/indra/llcorehttp/_httppolicyglobal.h
@@ -60,10 +60,10 @@ private:
 public:
 	HttpStatus set(HttpRequest::EPolicyOption opt, long value);
 	HttpStatus set(HttpRequest::EPolicyOption opt, const std::string & value);
-	HttpStatus set(HttpRequest::EPolicyOption opt, HttpRequest::policyCallback value);
+	HttpStatus set(HttpRequest::EPolicyOption opt, HttpRequest::policyCallback_t value);
 	HttpStatus get(HttpRequest::EPolicyOption opt, long * value) const;
 	HttpStatus get(HttpRequest::EPolicyOption opt, std::string * value) const;
-	HttpStatus get(HttpRequest::EPolicyOption opt, HttpRequest::policyCallback * value) const;
+	HttpStatus get(HttpRequest::EPolicyOption opt, HttpRequest::policyCallback_t * value) const;
 	
 public:
 	long				mConnectionLimit;
@@ -72,7 +72,7 @@ public:
 	std::string			mHttpProxy;
 	long				mTrace;
 	long				mUseLLProxy;
-	HttpRequest::policyCallback	mSslCtxCallback;
+	HttpRequest::policyCallback_t	mSslCtxCallback;
 };  // end class HttpPolicyGlobal
 
 }  // end namespace LLCore
diff --git a/indra/llcorehttp/_httpservice.cpp b/indra/llcorehttp/_httpservice.cpp
index 7b8aac35a8..252db78c89 100755
--- a/indra/llcorehttp/_httpservice.cpp
+++ b/indra/llcorehttp/_httpservice.cpp
@@ -415,7 +415,7 @@ HttpStatus HttpService::getPolicyOption(HttpRequest::EPolicyOption opt, HttpRequ
 }
 
 HttpStatus HttpService::getPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t pclass,
-	HttpRequest::policyCallback * ret_value)
+	HttpRequest::policyCallback_t * ret_value)
 {
 	HttpStatus status(HttpStatus::LLCORE, LLCore::HE_INVALID_ARG);
 
@@ -520,7 +520,7 @@ HttpStatus HttpService::setPolicyOption(HttpRequest::EPolicyOption opt, HttpRequ
 }
 
 HttpStatus HttpService::setPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t pclass,
-	HttpRequest::policyCallback value, HttpRequest::policyCallback * ret_value)
+	HttpRequest::policyCallback_t value, HttpRequest::policyCallback_t * ret_value)
 {
 	HttpStatus status(HttpStatus::LLCORE, LLCore::HE_INVALID_ARG);
 
diff --git a/indra/llcorehttp/_httpservice.h b/indra/llcorehttp/_httpservice.h
index 699a8eaa4f..ac518a5de7 100755
--- a/indra/llcorehttp/_httpservice.h
+++ b/indra/llcorehttp/_httpservice.h
@@ -209,15 +209,15 @@ protected:
 	HttpStatus getPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t,
 							   std::string * ret_value);
 	HttpStatus getPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t,
-								HttpRequest::policyCallback * ret_value);
+								HttpRequest::policyCallback_t * ret_value);
 
 	HttpStatus setPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t,
 							   long value, long * ret_value);
 	HttpStatus setPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t,
 							   const std::string & value, std::string * ret_value);
 	HttpStatus setPolicyOption(HttpRequest::EPolicyOption opt, HttpRequest::policy_t,
-								HttpRequest::policyCallback value, 
-								HttpRequest::policyCallback * ret_value);
+								HttpRequest::policyCallback_t value, 
+								HttpRequest::policyCallback_t * ret_value);
 
 protected:
 	static const OptionDescriptor		sOptionDesc[HttpRequest::PO_LAST];
diff --git a/indra/llcorehttp/httpcommon.h b/indra/llcorehttp/httpcommon.h
index 64075f5f20..ada5c1bbe7 100755
--- a/indra/llcorehttp/httpcommon.h
+++ b/indra/llcorehttp/httpcommon.h
@@ -190,6 +190,7 @@
 #include "linden_common.h"		// Modifies curl/curl.h interfaces
 #include "boost/intrusive_ptr.hpp"
 #include "boost/shared_ptr.hpp"
+#include "boost/function.hpp"
 #include <string>
 
 namespace LLCore
@@ -294,50 +295,50 @@ struct HttpStatus
 	typedef unsigned short type_enum_t;
 	
 	HttpStatus()
-		{
-			mDetails = new Details(LLCORE, HE_SUCCESS);
-	}
+	{
+		mDetails = boost::shared_ptr<Details>(new Details(LLCORE, HE_SUCCESS));
+    }
 
 	HttpStatus(type_enum_t type, short status)
-		{
-			mDetails = new Details(type, status);
-		}
+	{
+        mDetails = boost::shared_ptr<Details>(new Details(type, status));
+	}
 	
 	HttpStatus(int http_status)
-		{
-			mDetails = new Details(http_status, 
-				(http_status >= 200 && http_status <= 299) ? HE_SUCCESS : HE_REPLY_ERROR);
-			llassert(http_status >= 100 && http_status <= 999);
-		}
+	{
+        mDetails = boost::shared_ptr<Details>(new Details(http_status, 
+			(http_status >= 200 && http_status <= 299) ? HE_SUCCESS : HE_REPLY_ERROR));
+		llassert(http_status >= 100 && http_status <= 999);
+	}
 
 	HttpStatus(int http_status, const std::string &message)
-		{
-			mDetails = new Details(http_status,
-				(http_status >= 200 && http_status <= 299) ? HE_SUCCESS : HE_REPLY_ERROR);
-			llassert(http_status >= 100 && http_status <= 999);
-			mDetails->mMessage = message;
-		}
+	{
+        mDetails = boost::shared_ptr<Details>(new Details(http_status,
+			(http_status >= 200 && http_status <= 299) ? HE_SUCCESS : HE_REPLY_ERROR));
+		llassert(http_status >= 100 && http_status <= 999);
+		mDetails->mMessage = message;
+	}
 	
 	HttpStatus(const HttpStatus & rhs)
-		{
-			mDetails = new Details(*rhs.mDetails);
-		}
+	{
+		mDetails = rhs.mDetails;
+	}
 
 	~HttpStatus()
-		{
-			delete mDetails;
-		}
+	{
+	}
 
 	HttpStatus & operator=(const HttpStatus & rhs)
-		{
-			// Don't care if lhs & rhs are the same object
-			mDetails->mType = rhs.mDetails->mType;
-			mDetails->mStatus = rhs.mDetails->mStatus;
-			mDetails->mMessage = rhs.mDetails->mMessage;
-			mDetails->mErrorData = rhs.mDetails->mErrorData;
-
-			return *this;
-		}
+	{
+        mDetails = rhs.mDetails;
+		return *this;
+	}
+
+    HttpStatus & clone(const HttpStatus &rhs)
+    {
+        mDetails = boost::shared_ptr<Details>(new Details(*rhs.mDetails));
+        return *this;
+    }
 	
 	static const type_enum_t EXT_CURL_EASY = 0;			///< mStatus is an error from a curl_easy_*() call
 	static const type_enum_t EXT_CURL_MULTI = 1;		///< mStatus is an error from a curl_multi_*() call
@@ -365,8 +366,7 @@ struct HttpStatus
 	/// which will do the wrong thing in conditional expressions.
 	bool operator==(const HttpStatus & rhs) const
 	{
-		return (mDetails->mType == rhs.mDetails->mType) && 
-			(mDetails->mStatus == rhs.mDetails->mStatus);
+        return (*mDetails == *rhs.mDetails); 
 	}
 
 	bool operator!=(const HttpStatus & rhs) const
@@ -474,6 +474,10 @@ private:
 			mErrorData(rhs.mErrorData)
 		{}
 
+        bool operator == (const Details &rhs) const
+        {
+            return (mType == rhs.mType) && (mStatus == rhs.mStatus);
+        }
 
 		type_enum_t	mType;
 		short		mStatus;
@@ -481,8 +485,7 @@ private:
 		void *		mErrorData;
 	};
 
-	//boost::unique_ptr<Details>	mDetails;
-	Details * mDetails;
+    boost::shared_ptr<Details> mDetails;
 
 }; // end struct HttpStatus
 
diff --git a/indra/llcorehttp/httpoptions.cpp b/indra/llcorehttp/httpoptions.cpp
index 28c2c25e92..a4d08a80df 100755
--- a/indra/llcorehttp/httpoptions.cpp
+++ b/indra/llcorehttp/httpoptions.cpp
@@ -42,8 +42,8 @@ HttpOptions::HttpOptions() : RefCounted(true),
 	mUseRetryAfter(HTTP_USE_RETRY_AFTER_DEFAULT),
 	mFollowRedirects(false),
 	mVerifyPeer(false),
-	mVerifyHost(0),
-	mDNSCacheTimeout(15)
+	mVerifyHost(false),
+    mDNSCacheTimeout(-1L)
 {}
 
 
@@ -95,9 +95,9 @@ void HttpOptions::setSSLVerifyPeer(bool verify)
 	mVerifyPeer = verify;
 }
 
-void HttpOptions::setSSLVerifyHost(unsigned int type)
+void HttpOptions::setSSLVerifyHost(bool verify)
 {
-	mVerifyHost = llclamp<unsigned int>(type, 0, 2);
+	mVerifyHost = verify;
 }
 
 void HttpOptions::setDNSCacheTimeout(int timeout)
diff --git a/indra/llcorehttp/httpoptions.h b/indra/llcorehttp/httpoptions.h
index 3b9ad9598b..765d2431bb 100755
--- a/indra/llcorehttp/httpoptions.h
+++ b/indra/llcorehttp/httpoptions.h
@@ -69,72 +69,86 @@ protected:
 	void operator=(const HttpOptions &);		// Not defined
 
 public:
+
 	// Default:   false
 	void				setWantHeaders(bool wanted);
 	bool				getWantHeaders() const
-		{
-			return mWantHeaders;
-		}
+	{
+		return mWantHeaders;
+	}
 
 	// Default:  0
 	void				setTrace(int long);
 	int					getTrace() const
-		{
-			return mTracing;
-		}
+	{
+		return mTracing;
+	}
 
 	// Default:  30
 	void				setTimeout(unsigned int timeout);
 	unsigned int		getTimeout() const
-		{
-			return mTimeout;
-		}
+	{
+		return mTimeout;
+	}
 
 	// Default:  0
 	void				setTransferTimeout(unsigned int timeout);
 	unsigned int		getTransferTimeout() const
-		{
-			return mTransferTimeout;
-		}
+	{
+		return mTransferTimeout;
+	}
 
+    /// Sets the number of retries on an LLCore::HTTPRequest before the 
+    /// request fails.
 	// Default:  8
 	void				setRetries(unsigned int retries);
 	unsigned int		getRetries() const
-		{
-			return mRetries;
-		}
+	{
+		return mRetries;
+	}
 
 	// Default:  true
 	void				setUseRetryAfter(bool use_retry);
 	bool				getUseRetryAfter() const
-		{
-			return mUseRetryAfter;
-		}
+	{
+		return mUseRetryAfter;
+	}
 
-	// Default: false
+    /// Instructs the LLCore::HTTPRequest to follow redirects 
+	/// Default: false
 	void				setFollowRedirects(bool follow_redirect);
 	bool				getFollowRedirects() const
-		{
-			return mFollowRedirects;
-		}
-
-	void				setSSLVerifyPeer(bool verify);
+	{
+		return mFollowRedirects;
+	}
+
+    /// Instructs the LLCore::HTTPRequest to verify that the exchanged security
+    /// certificate is authentic. 
+    /// Default: false
+    void				setSSLVerifyPeer(bool verify);
 	bool				getSSLVerifyPeer() const
-		{
-			return mVerifyPeer;
-		}
-
-	void				setSSLVerifyHost(unsigned int type);
-	unsigned int		getSSLVerifyHost() const
-		{
-			return mVerifyHost;
-		}
-
+	{
+		return mVerifyPeer;
+	}
+
+    /// Instructs the LLCore::HTTPRequest to verify that the name in the 
+    /// security certificate matches the name of the host contacted.
+    /// Default: false
+    void				setSSLVerifyHost(bool verify);
+	bool	        	getSSLVerifyHost() const
+	{
+		return mVerifyHost;
+	}
+
+    /// Sets the time for DNS name caching in seconds.  Setting this value
+    /// to 0 will disable name caching.  Setting this value to -1 causes the 
+    /// name cache to never time out.
+    /// Default: -1
 	void				setDNSCacheTimeout(int timeout);
 	int					getDNSCacheTimeout() const
-		{
-			return mDNSCacheTimeout;
-		}
+	{
+		return mDNSCacheTimeout;
+	}
 	
 protected:
 	bool				mWantHeaders;
@@ -145,7 +159,7 @@ protected:
 	bool				mUseRetryAfter;
 	bool				mFollowRedirects;
 	bool				mVerifyPeer;
-	unsigned int		mVerifyHost;
+	bool        		mVerifyHost;
 	int					mDNSCacheTimeout;
 }; // end class HttpOptions
 
diff --git a/indra/llcorehttp/httprequest.cpp b/indra/llcorehttp/httprequest.cpp
index 5f1ed3d43b..df8502b947 100755
--- a/indra/llcorehttp/httprequest.cpp
+++ b/indra/llcorehttp/httprequest.cpp
@@ -117,7 +117,7 @@ HttpStatus HttpRequest::setStaticPolicyOption(EPolicyOption opt, policy_t pclass
 	return HttpService::instanceOf()->setPolicyOption(opt, pclass, value, ret_value);
 }
 
-HttpStatus HttpRequest::setStaticPolicyOption(EPolicyOption opt, policy_t pclass, policyCallback value, policyCallback * ret_value)
+HttpStatus HttpRequest::setStaticPolicyOption(EPolicyOption opt, policy_t pclass, policyCallback_t value, policyCallback_t * ret_value)
 {
 	if (HttpService::RUNNING == HttpService::instanceOf()->getState())
 	{
@@ -204,7 +204,7 @@ HttpHandle HttpRequest::requestGet(policy_t policy_id,
 	HttpStatus status;
 	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-	HttpOpRequest * op = new HttpOpRequest(this);
+	HttpOpRequest * op = new HttpOpRequest();
 	if (! (status = op->setupGet(policy_id, priority, url, options, headers)))
 	{
 		op->release();
@@ -238,7 +238,7 @@ HttpHandle HttpRequest::requestGetByteRange(policy_t policy_id,
 	HttpStatus status;
 	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-	HttpOpRequest * op = new HttpOpRequest(this);
+	HttpOpRequest * op = new HttpOpRequest();
 	if (! (status = op->setupGetByteRange(policy_id, priority, url, offset, len, options, headers)))
 	{
 		op->release();
@@ -271,7 +271,7 @@ HttpHandle HttpRequest::requestPost(policy_t policy_id,
 	HttpStatus status;
 	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-	HttpOpRequest * op = new HttpOpRequest(this);
+	HttpOpRequest * op = new HttpOpRequest();
 	if (! (status = op->setupPost(policy_id, priority, url, body, options, headers)))
 	{
 		op->release();
@@ -304,7 +304,7 @@ HttpHandle HttpRequest::requestPut(policy_t policy_id,
 	HttpStatus status;
 	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-	HttpOpRequest * op = new HttpOpRequest(this);
+	HttpOpRequest * op = new HttpOpRequest();
 	if (! (status = op->setupPut(policy_id, priority, url, body, options, headers)))
 	{
 		op->release();
diff --git a/indra/llcorehttp/httprequest.h b/indra/llcorehttp/httprequest.h
index 4cacb3a20b..f7ce82d412 100755
--- a/indra/llcorehttp/httprequest.h
+++ b/indra/llcorehttp/httprequest.h
@@ -237,7 +237,7 @@ public:
 
 	/// Prototype for policy based callbacks.  The callback methods will be executed
 	/// on the worker thread so no modifications should be made to the HttpHandler object.
-	typedef HttpStatus(*policyCallback)(const std::string &, HttpHandler const * const, void *);
+    typedef boost::function<HttpStatus(const std::string &, HttpHandler const * const, void *)> policyCallback_t;
 
 	/// Set a policy option for a global or class parameter at
 	/// startup time (prior to thread start).
@@ -255,7 +255,7 @@ public:
 	static HttpStatus setStaticPolicyOption(EPolicyOption opt, policy_t pclass,
 											const std::string & value, std::string * ret_value);
 	static HttpStatus setStaticPolicyOption(EPolicyOption opt, policy_t pclass,
-											policyCallback value, policyCallback * ret_value);;
+											policyCallback_t value, policyCallback_t * ret_value);;
 
 	/// Set a parameter on a class-based policy option.  Calls
 	/// made after the start of the servicing thread are
diff --git a/indra/llmessage/llhttpsdhandler.cpp b/indra/llmessage/llhttpsdhandler.cpp
index 0d385d6497..72ecfe77e2 100644
--- a/indra/llmessage/llhttpsdhandler.cpp
+++ b/indra/llmessage/llhttpsdhandler.cpp
@@ -89,7 +89,7 @@ LLHttpSDGenericHandler::LLHttpSDGenericHandler(const LLURI &uri, const std::stri
 {
 }
 
-void LLHttpSDGenericHandler::onSuccess(LLCore::HttpResponse * response, LLSD &content)
+void LLHttpSDGenericHandler::onSuccess(LLCore::HttpResponse * response, const LLSD &content)
 {
 	LL_DEBUGS() << mCaps << " Success." << LL_ENDL;
 }
diff --git a/indra/llmessage/llhttpsdhandler.h b/indra/llmessage/llhttpsdhandler.h
index b3eb7d6145..a2598c9709 100644
--- a/indra/llmessage/llhttpsdhandler.h
+++ b/indra/llmessage/llhttpsdhandler.h
@@ -49,7 +49,7 @@ public:
 	}
 
 protected:
-	virtual void onSuccess(LLCore::HttpResponse * response, LLSD &content) = 0;
+	virtual void onSuccess(LLCore::HttpResponse * response, const LLSD &content) = 0;
 	virtual void onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status) = 0;
 
 private:
@@ -65,7 +65,7 @@ public:
 	LLHttpSDGenericHandler(const LLURI &uri, const std::string &action);
 
 protected:
-	virtual void onSuccess(LLCore::HttpResponse * response, LLSD &content);
+	virtual void onSuccess(LLCore::HttpResponse * response, const LLSD &content);
 	virtual void onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status);
 
 private:
diff --git a/indra/newview/llagent.cpp b/indra/newview/llagent.cpp
index 81387fb927..667d530e39 100755
--- a/indra/newview/llagent.cpp
+++ b/indra/newview/llagent.cpp
@@ -2559,7 +2559,7 @@ public:
 	{ }
 
 protected:
-	virtual void onSuccess(LLCore::HttpResponse * response, LLSD &content);
+	virtual void onSuccess(LLCore::HttpResponse * response, const LLSD &content);
 	virtual void onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status);
 
 private:
@@ -2572,7 +2572,7 @@ private:
 };
 
 //-------------------------------------------------------------------------
-void LLMaturityHttpHandler::onSuccess(LLCore::HttpResponse * response, LLSD &content)
+void LLMaturityHttpHandler::onSuccess(LLCore::HttpResponse * response, const LLSD &content)
 {
 	U8 actualMaturity = parseMaturityFromServerResponse(content);
 
@@ -2774,7 +2774,7 @@ void LLAgent::sendMaturityPreferenceToServer(U8 pPreferredMaturity)
 		LL_INFOS() << "Sending viewer preferred maturity to '" << LLViewerRegion::accessToString(pPreferredMaturity)
 			<< "' via capability to: " << url << LL_ENDL;
 
-		LLCore::HttpHandle handle = requestPostCapibility("UpdateAgentInformation", url, postData, handler);
+		LLCore::HttpHandle handle = requestPostCapability("UpdateAgentInformation", url, postData, handler);
 
 		if (handle == LLCORE_HTTP_HANDLE_INVALID)
 		{
@@ -2784,7 +2784,7 @@ void LLAgent::sendMaturityPreferenceToServer(U8 pPreferredMaturity)
 	}
 }
 
-LLCore::HttpHandle LLAgent::requestPostCapibility(const std::string &cap, const std::string &url, LLSD &postData, LLHttpSDHandler *usrhndlr)
+LLCore::HttpHandle LLAgent::requestPostCapability(const std::string &cap, const std::string &url, LLSD &postData, LLHttpSDHandler *usrhndlr)
 {
 	LLHttpSDHandler * handler = (usrhndlr) ? usrhndlr : new LLHttpSDGenericHandler(url, cap);
 	LLCore::HttpHandle handle = LLCoreHttpUtil::requestPostWithLLSD(mHttpRequest,
@@ -2793,6 +2793,9 @@ LLCore::HttpHandle LLAgent::requestPostCapibility(const std::string &cap, const
 
 	if (handle == LLCORE_HTTP_HANDLE_INVALID)
 	{
+        // If no handler was passed in we delete the handler default handler allocated 
+        // at the start of this function.
+        // *TODO: Change this metaphore to use boost::shared_ptr<> for handlers.  Requires change in LLCore::HTTP
 		if (!usrhndlr)
 			delete handler;
 		LLCore::HttpStatus status = mHttpRequest->getStatus();
diff --git a/indra/newview/llagent.h b/indra/newview/llagent.h
index 6b636a2dc0..26120b52f6 100755
--- a/indra/newview/llagent.h
+++ b/indra/newview/llagent.h
@@ -925,8 +925,8 @@ public:
 public:
 	/// Utilities for allowing the the agent sub managers to post and get via
 	/// HTTP using the agent's policy settings and headers.
-	LLCore::HttpHandle	requestPostCapibility(const std::string &cap, const std::string &url, LLSD &postData, LLHttpSDHandler *usrhndlr = NULL);
-	//LLCore::HttpHandle	httpGetCapibility(const std::string &cap, const LLURI &uri, LLHttpSDHandler *usrhndlr = NULL);
+	LLCore::HttpHandle	requestPostCapability(const std::string &cap, const std::string &url, LLSD &postData, LLHttpSDHandler *usrhndlr = NULL);
+	//LLCore::HttpHandle	httpGetCapability(const std::string &cap, const LLURI &uri, LLHttpSDHandler *usrhndlr = NULL);
 
 /**                    Utility
  **                                                                            **
diff --git a/indra/newview/llagentlanguage.cpp b/indra/newview/llagentlanguage.cpp
index 81fce9b257..f2ac323578 100755
--- a/indra/newview/llagentlanguage.cpp
+++ b/indra/newview/llagentlanguage.cpp
@@ -71,7 +71,7 @@ bool LLAgentLanguage::update()
 		body["language_is_public"] = gSavedSettings.getBOOL("LanguageIsPublic");
 		
 		//LLHTTPClient::post(url, body, new LLHTTPClient::Responder);
-		LLCore::HttpHandle handle = gAgent.requestPostCapibility("UpdateAgentLanguage", url, body);
+		LLCore::HttpHandle handle = gAgent.requestPostCapability("UpdateAgentLanguage", url, body);
 		if (handle == LLCORE_HTTP_HANDLE_INVALID)
 		{
 			LL_WARNS() << "Unable to change language." << LL_ENDL;
diff --git a/indra/newview/llappcorehttp.cpp b/indra/newview/llappcorehttp.cpp
index cd9166f7b7..51cca273d8 100755
--- a/indra/newview/llappcorehttp.cpp
+++ b/indra/newview/llappcorehttp.cpp
@@ -494,7 +494,7 @@ LLCore::HttpStatus LLAppCoreHttp::sslVerify(const std::string &url,
 
 	validation_params[CERT_HOSTNAME] = uri.hostName();
 
-	// *TODO*: In the case of an exception while validating the cert, we need a way
+	// *TODO: In the case of an exception while validating the cert, we need a way
 	// to pass the offending(?) cert back out. *Rider*
 
 	try
diff --git a/indra/newview/llappearancemgr.cpp b/indra/newview/llappearancemgr.cpp
index be71c430f4..709d9881e1 100755
--- a/indra/newview/llappearancemgr.cpp
+++ b/indra/newview/llappearancemgr.cpp
@@ -1260,7 +1260,7 @@ public:
 	virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);
 
 protected:
-	virtual void onSuccess(LLCore::HttpResponse * response, LLSD &content);
+	virtual void onSuccess(LLCore::HttpResponse * response, const LLSD &content);
 	virtual void onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status);
 
 private:
@@ -1278,7 +1278,7 @@ void LLAppearanceMgrHttpHandler::onCompleted(LLCore::HttpHandle handle, LLCore::
 	LLHttpSDHandler::onCompleted(handle, response);
 }
 
-void LLAppearanceMgrHttpHandler::onSuccess(LLCore::HttpResponse * response, LLSD &content)
+void LLAppearanceMgrHttpHandler::onSuccess(LLCore::HttpResponse * response, const LLSD &content)
 {
 	if (!content.isMap())
 	{
@@ -3443,7 +3443,7 @@ void LLAppearanceMgr::requestServerAppearanceUpdate()
 	gAgentAvatarp->mLastUpdateRequestCOFVersion = cof_version;
 
 
-	LLCore::HttpHandle handle = gAgent.requestPostCapibility("UpdateAvatarAppearance", url, postData, handler);
+	LLCore::HttpHandle handle = gAgent.requestPostCapability("UpdateAvatarAppearance", url, postData, handler);
 
 	if (handle == LLCORE_HTTP_HANDLE_INVALID)
 	{
diff --git a/indra/newview/llavatarrenderinfoaccountant.cpp b/indra/newview/llavatarrenderinfoaccountant.cpp
index 38e153137c..aeaa832bc7 100644
--- a/indra/newview/llavatarrenderinfoaccountant.cpp
+++ b/indra/newview/llavatarrenderinfoaccountant.cpp
@@ -43,7 +43,9 @@
 #include "llviewerregion.h"
 #include "llvoavatar.h"
 #include "llworld.h"
-
+#include "llhttpsdhandler.h"
+#include "httpheaders.h"
+#include "httpoptions.h"
 
 static	const std::string KEY_AGENTS = "agents";			// map
 static 	const std::string KEY_WEIGHT = "weight";			// integer
@@ -55,8 +57,113 @@ static	const std::string KEY_ERROR = "error";
 
 // Send data updates about once per minute, only need per-frame resolution
 LLFrameTimer LLAvatarRenderInfoAccountant::sRenderInfoReportTimer;
+//LLCore::HttpRequest::ptr_t LLAvatarRenderInfoAccountant::sHttpRequest;
+
+#if 0
+//=========================================================================
+class LLAvatarRenderInfoHandler : public LLHttpSDHandler
+{
+public:
+	LLAvatarRenderInfoHandler(const LLURI &uri, U64 regionHandle);
+
+protected:
+	virtual void onSuccess(LLCore::HttpResponse * response, LLSD &content);
+	virtual void onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status);
+
+private:
+	U64	mRegionHandle;
+};
+
+LLAvatarRenderInfoHandler::LLAvatarRenderInfoHandler(const LLURI &uri, U64 regionHandle) :
+	LLHttpSDHandler(uri),
+	mRegionHandle(regionHandle)
+{
+}
+
+void LLAvatarRenderInfoHandler::onSuccess(LLCore::HttpResponse * response, LLSD &content)
+{
+	LLViewerRegion * regionp = LLWorld::getInstance()->getRegionFromHandle(mRegionHandle);
+	if (regionp)
+	{
+		if (LLAvatarRenderInfoAccountant::logRenderInfo())
+		{
+			LL_INFOS() << "LRI: Result for avatar weights request for region " << regionp->getName() << ":" << LL_ENDL;
+		}
+
+		if (content.isMap())
+		{
+			if (content.has(KEY_AGENTS))
+			{
+				const LLSD & agents = content[KEY_AGENTS];
+				if (agents.isMap())
+				{
+					LLSD::map_const_iterator	report_iter = agents.beginMap();
+					while (report_iter != agents.endMap())
+					{
+						LLUUID target_agent_id = LLUUID(report_iter->first);
+						const LLSD & agent_info_map = report_iter->second;
+						LLViewerObject* avatarp = gObjectList.findObject(target_agent_id);
+						if (avatarp &&
+							avatarp->isAvatar() &&
+							agent_info_map.isMap())
+						{	// Extract the data for this avatar
+
+							if (LLAvatarRenderInfoAccountant::logRenderInfo())
+							{
+								LL_INFOS() << "LRI:  Agent " << target_agent_id
+									<< ": " << agent_info_map << LL_ENDL;
+							}
+
+							if (agent_info_map.has(KEY_WEIGHT))
+							{
+								((LLVOAvatar *)avatarp)->setReportedVisualComplexity(agent_info_map[KEY_WEIGHT].asInteger());
+							}
+						}
+						report_iter++;
+					}
+				}
+			}	// has "agents"
+			else if (content.has(KEY_ERROR))
+			{
+				const LLSD & error = content[KEY_ERROR];
+				LL_WARNS() << "Avatar render info GET error: "
+					<< error[KEY_IDENTIFIER]
+					<< ": " << error[KEY_MESSAGE]
+					<< " from region " << regionp->getName()
+					<< LL_ENDL;
+			}
+		}
+	}
+	else
+	{
+		LL_INFOS() << "Avatar render weight info received but region not found for "
+			<< mRegionHandle << LL_ENDL;
+	}
+}
 
+void LLAvatarRenderInfoHandler::onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status)
+{
+	LLViewerRegion * regionp = LLWorld::getInstance()->getRegionFromHandle(mRegionHandle);
+	if (regionp)
+	{
+		LL_WARNS() << "HTTP error result for avatar weight GET: " << status.toULong()
+			<< ", " << status.toString()
+			<< " returned by region " << regionp->getName()
+			<< LL_ENDL;
+	}
+	else
+	{
+		LL_WARNS() << "Avatar render weight GET error received but region not found for " 
+			<< mRegionHandle 
+			<< ", error " << status.toULong()
+			<< ", " << status.toString()
+			<< LL_ENDL;
+	}
+}
 
+
+//-------------------------------------------------------------------------
+#else
 // HTTP responder class for GET request for avatar render weight information
 class LLAvatarRenderInfoGetResponder : public LLHTTPClient::Responder
 {
@@ -142,7 +249,7 @@ public:
 		}
 		else
 		{
-			LL_INFOS() << "Avatar render weight info recieved but region not found for " 
+			LL_INFOS() << "Avatar render weight info received but region not found for " 
 				<< mRegionHandle << LL_ENDL;
 		}
 	}
@@ -150,7 +257,7 @@ public:
 private:
 	U64		mRegionHandle;
 };
-
+#endif
 
 // HTTP responder class for POST request for avatar render weight information
 class LLAvatarRenderInfoPostResponder : public LLHTTPClient::Responder
@@ -172,7 +279,7 @@ public:
 		}
 		else
 		{
-			LL_WARNS() << "Avatar render weight POST error recieved but region not found for " 
+			LL_WARNS() << "Avatar render weight POST error received but region not found for " 
 				<< mRegionHandle 
 				<< ", error " << statusNum 
 				<< ", " << reason
@@ -215,7 +322,6 @@ private:
 	U64		mRegionHandle;
 };
 
-
 // static 
 // Send request for one region, no timer checks
 void LLAvatarRenderInfoAccountant::sendRenderInfoToRegion(LLViewerRegion * regionp)
@@ -292,7 +398,19 @@ void LLAvatarRenderInfoAccountant::getRenderInfoFromRegion(LLViewerRegion * regi
 		}
 
 		// First send a request to get the latest data
+#if 0
+		if (!LLAvatarRenderInfoAccountant::sHttpRequest)
+			sHttpRequest = LLCore::HttpRequest::ptr_t(new LLCore::HttpRequest());
+		LLAppCoreHttp & app_core_http(LLAppViewer::instance()->getAppCoreHttp());
+
+		LLCore::HttpHeaders::ptr_t httpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false);
+		LLCore::HttpOptions::ptr_t httpOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false);
+		LLCore::HttpRequest::policy_t httpPolicy = app_core_http.getPolicy(LLAppCoreHttp::AP_AGENT);
+
+		LLCore::HttpHandle handle = sHttpRequest->
+#else
 		LLHTTPClient::get(url, new LLAvatarRenderInfoGetResponder(regionp->getHandle()));
+#endif
 	}
 }
 
@@ -301,6 +419,9 @@ void LLAvatarRenderInfoAccountant::getRenderInfoFromRegion(LLViewerRegion * regi
 // Called every frame - send render weight requests to every region
 void LLAvatarRenderInfoAccountant::idle()
 {
+//	if (!LLAvatarRenderInfoAccountant::sHttpRequest)
+//		sHttpRequest = LLCore::HttpRequest::ptr_t(new LLCore::HttpRequest());
+
 	if (sRenderInfoReportTimer.hasExpired())
 	{
 		const F32 SECS_BETWEEN_REGION_SCANS   =  5.f;		// Scan the region list every 5 seconds
diff --git a/indra/newview/llavatarrenderinfoaccountant.h b/indra/newview/llavatarrenderinfoaccountant.h
index d68f2dccfb..13054f5e2f 100644
--- a/indra/newview/llavatarrenderinfoaccountant.h
+++ b/indra/newview/llavatarrenderinfoaccountant.h
@@ -29,6 +29,8 @@
 #if ! defined(LL_llavatarrenderinfoaccountant_H)
 #define LL_llavatarrenderinfoaccountant_H
 
+#include "httpcommon.h"
+
 class LLViewerRegion;
 
 // Class to gather avatar rendering information 
@@ -36,8 +38,6 @@ class LLViewerRegion;
 class LLAvatarRenderInfoAccountant
 {
 public:
-	LLAvatarRenderInfoAccountant()	{};
-	~LLAvatarRenderInfoAccountant()	{};
 
 	static void sendRenderInfoToRegion(LLViewerRegion * regionp);
 	static void getRenderInfoFromRegion(LLViewerRegion * regionp);
@@ -49,8 +49,14 @@ public:
 	static bool logRenderInfo();
 
 private:
+	LLAvatarRenderInfoAccountant() {};
+	~LLAvatarRenderInfoAccountant()	{};
+
 	// Send data updates about once per minute, only need per-frame resolution
 	static LLFrameTimer sRenderInfoReportTimer;
+
+//	static LLCore::HttpRequest::ptr_t	sHttpRequest;
+
 };
 
 #endif /* ! defined(LL_llavatarrenderinfoaccountant_H) */
diff --git a/indra/newview/llmaterialmgr.cpp b/indra/newview/llmaterialmgr.cpp
index 065d763596..78fbe9af0a 100755
--- a/indra/newview/llmaterialmgr.cpp
+++ b/indra/newview/llmaterialmgr.cpp
@@ -75,7 +75,7 @@ public:
 	virtual ~LLMaterialHttpHandler();
 
 protected:
-	virtual void onSuccess(LLCore::HttpResponse * response, LLSD &content);
+	virtual void onSuccess(LLCore::HttpResponse * response, const LLSD &content);
 	virtual void onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status);
 
 private:
@@ -95,7 +95,7 @@ LLMaterialHttpHandler::~LLMaterialHttpHandler()
 {
 }
 
-void LLMaterialHttpHandler::onSuccess(LLCore::HttpResponse * response, LLSD &content)
+void LLMaterialHttpHandler::onSuccess(LLCore::HttpResponse * response, const LLSD &content)
 {
 	LL_DEBUGS("Materials") << LL_ENDL;
 	mCallback(true, content);
-- 
cgit v1.3


From 0b02b36b651987d5d24c225fa9472e0d35803559 Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Fri, 27 Mar 2015 17:38:00 -0700
Subject: Remove test for size of HttpStatus

---
 indra/llcorehttp/tests/test_httpstatus.hpp | 36 +++++++++++++++---------------
 1 file changed, 18 insertions(+), 18 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/tests/test_httpstatus.hpp b/indra/llcorehttp/tests/test_httpstatus.hpp
index 5f8ed14c51..4502d32fe1 100755
--- a/indra/llcorehttp/tests/test_httpstatus.hpp
+++ b/indra/llcorehttp/tests/test_httpstatus.hpp
@@ -83,21 +83,21 @@ void HttpStatusTestObjectType::test<1>()
 }
 
 
-template <> template <>
-void HttpStatusTestObjectType::test<2>()
-{
-	set_test_name("HttpStatus memory structure");
-
-	// Require that an HttpStatus object can be trivially
-	// returned as a function return value in registers.
-	// One should fit in an int on all platforms.
-
-	ensure(sizeof(HttpStatus) <= sizeof(int));
-}
+// template <> template <>
+// void HttpStatusTestObjectType::test<2>()
+// {
+// 	set_test_name("HttpStatus memory structure");
+// 
+// 	// Require that an HttpStatus object can be trivially
+// 	// returned as a function return value in registers.
+// 	// One should fit in an int on all platforms.
+// 
+// 	//ensure(sizeof(HttpStatus) <= sizeof(int));
+// }
 
 
 template <> template <>
-void HttpStatusTestObjectType::test<3>()
+void HttpStatusTestObjectType::test<2>()
 {
 	set_test_name("HttpStatus valid status string conversion");
 	
@@ -124,7 +124,7 @@ void HttpStatusTestObjectType::test<3>()
 
 
 template <> template <>
-void HttpStatusTestObjectType::test<4>()
+void HttpStatusTestObjectType::test<3>()
 {
 	set_test_name("HttpStatus invalid status string conversion");
 	
@@ -145,7 +145,7 @@ void HttpStatusTestObjectType::test<4>()
 }
 
 template <> template <>
-void HttpStatusTestObjectType::test<5>()
+void HttpStatusTestObjectType::test<4>()
 {
 	set_test_name("HttpStatus equality/inequality testing");
 
@@ -164,7 +164,7 @@ void HttpStatusTestObjectType::test<5>()
 }
 
 template <> template <>
-void HttpStatusTestObjectType::test<6>()
+void HttpStatusTestObjectType::test<5>()
 {
 	set_test_name("HttpStatus basic HTTP status encoding");
 	
@@ -205,7 +205,7 @@ void HttpStatusTestObjectType::test<6>()
 }
 
 template <> template <>
-void HttpStatusTestObjectType::test<7>()
+void HttpStatusTestObjectType::test<6>()
 {
 	set_test_name("HttpStatus HTTP status text strings");
 
@@ -237,7 +237,7 @@ void HttpStatusTestObjectType::test<7>()
 
 
 template <> template <>
-void HttpStatusTestObjectType::test<8>()
+void HttpStatusTestObjectType::test<7>()
 {
 	set_test_name("HttpStatus toHex() nominal function");
 	
@@ -249,7 +249,7 @@ void HttpStatusTestObjectType::test<8>()
 
 
 template <> template <>
-void HttpStatusTestObjectType::test<9>()
+void HttpStatusTestObjectType::test<8>()
 {
 	set_test_name("HttpStatus toTerseString() nominal function");
 	
-- 
cgit v1.3


From edc1439bd633bdac183fbecc131edd55074b5442 Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Wed, 1 Apr 2015 16:37:00 -0700
Subject: Added AvatarNameCache as coroutine, with LLCore::HttpHandler to
 respond correctly to Event Pumps. Added get/setRequestURL() to
 LLCore::HttpResponse Removed URI from the HttpSDHandler.

---
 indra/llcorehttp/_httpoprequest.cpp   |   4 +-
 indra/llcorehttp/httpresponse.cpp     |   3 +-
 indra/llcorehttp/httpresponse.h       |  11 ++
 indra/llmessage/llavatarnamecache.cpp | 286 +++++++++++++++++++++++-----------
 indra/llmessage/llavatarnamecache.h   |   7 +-
 indra/llmessage/llcorehttputil.cpp    |  96 +++++++++++-
 indra/llmessage/llcorehttputil.h      |  30 ++++
 indra/llmessage/llhttpsdhandler.cpp   |  12 +-
 indra/llmessage/llhttpsdhandler.h     |  11 +-
 indra/newview/llagent.cpp             |  55 ++++---
 indra/newview/llagent.h               |  10 +-
 indra/newview/llappearancemgr.cpp     |   8 +-
 indra/newview/llmaterialmgr.cpp       |  14 +-
 13 files changed, 405 insertions(+), 142 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/_httpoprequest.cpp b/indra/llcorehttp/_httpoprequest.cpp
index 5768fe5a90..7c2309b31d 100755
--- a/indra/llcorehttp/_httpoprequest.cpp
+++ b/indra/llcorehttp/_httpoprequest.cpp
@@ -260,7 +260,9 @@ void HttpOpRequest::visitNotifier(HttpRequest * request)
 		response->setStatus(mStatus);
 		response->setBody(mReplyBody);
 		response->setHeaders(mReplyHeaders);
-		if (mReplyOffset || mReplyLength)
+        response->setRequestURL(mReqURL);
+
+        if (mReplyOffset || mReplyLength)
 		{
 			// Got an explicit offset/length in response
 			response->setRange(mReplyOffset, mReplyLength, mReplyFullLength);
diff --git a/indra/llcorehttp/httpresponse.cpp b/indra/llcorehttp/httpresponse.cpp
index 87e3426415..7d88f02527 100755
--- a/indra/llcorehttp/httpresponse.cpp
+++ b/indra/llcorehttp/httpresponse.cpp
@@ -41,7 +41,8 @@ HttpResponse::HttpResponse()
 	  mBufferArray(NULL),
 	  mHeaders(NULL),
 	  mRetries(0U),
-	  m503Retries(0U)
+	  m503Retries(0U),
+      mRequestUrl()
 {}
 
 
diff --git a/indra/llcorehttp/httpresponse.h b/indra/llcorehttp/httpresponse.h
index 39b582ff85..6c3b4da5e6 100755
--- a/indra/llcorehttp/httpresponse.h
+++ b/indra/llcorehttp/httpresponse.h
@@ -194,6 +194,16 @@ public:
 			return mStats;
 		}
 
+    void setRequestURL(const std::string &url)
+        {
+            mRequestUrl = url;
+        }
+
+    const std::string &getRequestURL() const
+        {
+            return mRequestUrl;
+        }
+
 
 protected:
 	// Response data here
@@ -206,6 +216,7 @@ protected:
 	std::string			mContentType;
 	unsigned int		mRetries;
 	unsigned int		m503Retries;
+    std::string         mRequestUrl;
 
 	TransferStats::ptr_t	mStats;
 };
diff --git a/indra/llmessage/llavatarnamecache.cpp b/indra/llmessage/llavatarnamecache.cpp
index d02a60b7b2..88859819e0 100755
--- a/indra/llmessage/llavatarnamecache.cpp
+++ b/indra/llmessage/llavatarnamecache.cpp
@@ -33,9 +33,18 @@
 #include "llhttpclient.h"
 #include "llsd.h"
 #include "llsdserialize.h"
-
+#include "httpresponse.h"
+#include "llhttpsdhandler.h"
 #include <boost/tokenizer.hpp>
 
+#include "httpcommon.h"
+#include "httprequest.h"
+#include "httpheaders.h"
+#include "httpoptions.h"
+#include "llcoros.h"
+#include "lleventcoro.h"
+#include "llcorehttputil.h"
+
 #include <map>
 #include <set>
 
@@ -90,6 +99,12 @@ namespace LLAvatarNameCache
 	// Time-to-live for a temp cache entry.
 	const F64 TEMP_CACHE_ENTRY_LIFETIME = 60.0;
 
+    LLCore::HttpRequest::ptr_t		sHttpRequest;
+    LLCore::HttpHeaders::ptr_t		sHttpHeaders;
+    LLCore::HttpOptions::ptr_t		sHttpOptions;
+    LLCore::HttpRequest::policy_t	sHttpPolicy;
+    LLCore::HttpRequest::priority_t	sHttpPriority;
+
 	//-----------------------------------------------------------------------
 	// Internal methods
 	//-----------------------------------------------------------------------
@@ -121,7 +136,13 @@ namespace LLAvatarNameCache
 	// Erase expired names from cache
 	void eraseUnrefreshed();
 
-	bool expirationFromCacheControl(const LLSD& headers, F64 *expires);
+    //bool expirationFromCacheControl(LLCore::HttpHeaders *headers, F64 *expires);
+    bool expirationFromCacheControl(const LLSD& headers, F64 *expires);
+
+    // This is a coroutine.  The only parameter that can be specified as a reference is the self
+    void requestAvatarNameCache_(LLCoros::self& self, std::string url, std::vector<LLUUID> agentIds);
+
+    void handleAvNameCacheSuccess(const LLSD &data, const LLSD &httpResult);
 }
 
 /* Sample response:
@@ -163,94 +184,125 @@ namespace LLAvatarNameCache
 </llsd>
 */
 
-class LLAvatarNameResponder : public LLHTTPClient::Responder
+// Coroutine for sending and processing avatar name cache requests.  
+// Do not call directly.  See documentation in lleventcoro.h and llcoro.h for
+// further explanation.
+void LLAvatarNameCache::requestAvatarNameCache_(LLCoros::self& self, std::string url, std::vector<LLUUID> agentIds)
 {
-	LOG_CLASS(LLAvatarNameResponder);
-private:
-	// need to store agent ids that are part of this request in case of
-	// an error, so we can flag them as unavailable
-	std::vector<LLUUID> mAgentIDs;
-
-public:
-	LLAvatarNameResponder(const std::vector<LLUUID>& agent_ids)
-	:	mAgentIDs(agent_ids)
-	{ }
-	
-protected:
-	/*virtual*/ void httpSuccess()
-	{
-		const LLSD& content = getContent();
-		if (!content.isMap())
-		{
-			failureResult(HTTP_INTERNAL_ERROR, "Malformed response contents", content);
-			return;
-		}
-		// Pull expiration out of headers if available
-		F64 expires = LLAvatarNameCache::nameExpirationFromHeaders(getResponseHeaders());
-		F64 now = LLFrameTimer::getTotalSeconds();
+    LLEventStream  replyPump("NameCacheReply", true);
+    LLCoreHttpUtil::HttpCoroHandler::ptr_t httpHandler = 
+        LLCoreHttpUtil::HttpCoroHandler::ptr_t(new LLCoreHttpUtil::HttpCoroHandler(replyPump));
 
-		const LLSD& agents = content["agents"];
-		LLSD::array_const_iterator it = agents.beginArray();
-		for ( ; it != agents.endArray(); ++it)
-		{
-			const LLSD& row = *it;
-			LLUUID agent_id = row["id"].asUUID();
+    LL_DEBUGS("AvNameCache") << "Entering coroutine " << LLCoros::instance().getName(self)
+        << " with url '" << url << "', requesting " << agentIds.size() << " Agent Ids" << LL_ENDL;
 
-			LLAvatarName av_name;
-			av_name.fromLLSD(row);
+    try
+    {
+        bool success = true;
 
-			// Use expiration time from header
-			av_name.mExpires = expires;
+        LLAvatarNameCache::sHttpRequest->requestGet(
+            LLAvatarNameCache::sHttpPolicy, LLAvatarNameCache::sHttpPriority, 
+            url, LLAvatarNameCache::sHttpOptions.get(), 
+            LLAvatarNameCache::sHttpHeaders.get(), httpHandler.get());
 
-			LL_DEBUGS("AvNameCache") << "LLAvatarNameResponder::result for " << agent_id << LL_ENDL;
-			av_name.dump();
-			
-			// cache it and fire signals
-			LLAvatarNameCache::processName(agent_id, av_name);
-		}
+        LLSD results = waitForEventOn(self, replyPump);
+        LLSD httpResults;
 
-		// Same logic as error response case
-		const LLSD& unresolved_agents = content["bad_ids"];
-		S32  num_unresolved = unresolved_agents.size();
-		if (num_unresolved > 0)
-		{
-            LL_WARNS("AvNameCache") << "LLAvatarNameResponder::result " << num_unresolved << " unresolved ids; "
-                                    << "expires in " << expires - now << " seconds"
-                                    << LL_ENDL;
-			it = unresolved_agents.beginArray();
-			for ( ; it != unresolved_agents.endArray(); ++it)
-			{
-				const LLUUID& agent_id = *it;
+        LL_DEBUGS() << results << LL_ENDL;
 
-				LL_WARNS("AvNameCache") << "LLAvatarNameResponder::result "
-                                        << "failed id " << agent_id
-                                        << LL_ENDL;
+        if (!results.isMap())
+        {
+            LL_WARNS("AvNameCache") << " Invalid result returned from LLCoreHttpUtil::HttpCoroHandler." << LL_ENDL;
+            success = false;
+        }
+        else
+        {
+            httpResults = results["http_result"];
+            success = httpResults["success"].asBoolean();
+            if (!success)
+            {
+                LL_WARNS("AvNameCache") << "Error result from LLCoreHttpUtil::HttpCoroHandler. Code "
+                    << httpResults["status"] << ": '" << httpResults["message"] << "'" << LL_ENDL;
+            }
+        }
 
+        if (!success)
+        {   // on any sort of failure add dummy records for any agent IDs 
+            // in this request that we do not have cached already
+            std::vector<LLUUID>::const_iterator it = agentIds.begin();
+            for ( ; it != agentIds.end(); ++it)
+            {
+                const LLUUID& agent_id = *it;
                 LLAvatarNameCache::handleAgentError(agent_id);
-			}
-		}
-        LL_DEBUGS("AvNameCache") << "LLAvatarNameResponder::result " 
-                                 << LLAvatarNameCache::sCache.size() << " cached names"
-                                 << LL_ENDL;
+            }
+            return;
+        }
+
+        LLAvatarNameCache::handleAvNameCacheSuccess(results, httpResults);
+
     }
+    catch (std::exception e)
+    {
+        LL_WARNS() << "Caught exception '" << e.what() << "'" << LL_ENDL;
+    }
+    catch (...)
+    {
+        LL_WARNS() << "Caught unknown exception." << LL_ENDL;
+    }
+}
 
-	/*virtual*/ void httpFailure()
-	{
-		// If there's an error, it might be caused by PeopleApi,
-		// or when loading textures on startup and using a very slow 
-		// network, this query may time out.
-		// What we should do depends on whether or not we have a cached name
-		LL_WARNS("AvNameCache") << dumpResponse() << LL_ENDL;
-
-		// Add dummy records for any agent IDs in this request that we do not have cached already
-		std::vector<LLUUID>::const_iterator it = mAgentIDs.begin();
-		for ( ; it != mAgentIDs.end(); ++it)
-		{
-			const LLUUID& agent_id = *it;
-			LLAvatarNameCache::handleAgentError(agent_id);
-		}
-	}
-};
+void LLAvatarNameCache::handleAvNameCacheSuccess(const LLSD &data, const LLSD &httpResult)
+{
+
+    LLSD headers = httpResult["headers"];
+    // Pull expiration out of headers if available
+    F64 expires = LLAvatarNameCache::nameExpirationFromHeaders(headers);
+    F64 now = LLFrameTimer::getTotalSeconds();
+
+    const LLSD& agents = data["agents"];
+    LLSD::array_const_iterator it = agents.beginArray();
+    for (; it != agents.endArray(); ++it)
+    {
+        const LLSD& row = *it;
+        LLUUID agent_id = row["id"].asUUID();
+
+        LLAvatarName av_name;
+        av_name.fromLLSD(row);
+
+        // Use expiration time from header
+        av_name.mExpires = expires;
+
+        LL_DEBUGS("AvNameCache") << "LLAvatarNameResponder::result for " << agent_id << LL_ENDL;
+        av_name.dump();
+
+        // cache it and fire signals
+        LLAvatarNameCache::processName(agent_id, av_name);
+    }
+
+    // Same logic as error response case
+    const LLSD& unresolved_agents = data["bad_ids"];
+    S32  num_unresolved = unresolved_agents.size();
+    if (num_unresolved > 0)
+    {
+        LL_WARNS("AvNameCache") << "LLAvatarNameResponder::result " << num_unresolved << " unresolved ids; "
+            << "expires in " << expires - now << " seconds"
+            << LL_ENDL;
+        it = unresolved_agents.beginArray();
+        for (; it != unresolved_agents.endArray(); ++it)
+        {
+            const LLUUID& agent_id = *it;
+
+            LL_WARNS("AvNameCache") << "LLAvatarNameResponder::result "
+                << "failed id " << agent_id
+                << LL_ENDL;
+
+            LLAvatarNameCache::handleAgentError(agent_id);
+        }
+    }
+    LL_DEBUGS("AvNameCache") << "LLAvatarNameResponder::result "
+        << LLAvatarNameCache::sCache.size() << " cached names"
+        << LL_ENDL;
+}
 
 // Provide some fallback for agents that return errors
 void LLAvatarNameCache::handleAgentError(const LLUUID& agent_id)
@@ -353,12 +405,17 @@ void LLAvatarNameCache::requestNamesViaCapability()
 		}
 	}
 
-	if (!url.empty())
-	{
-		LL_DEBUGS("AvNameCache") << "LLAvatarNameCache::requestNamesViaCapability requested "
-								 << ids << " ids"
-								 << LL_ENDL;
-		LLHTTPClient::get(url, new LLAvatarNameResponder(agent_ids));
+    if (!url.empty())
+    {
+        LL_DEBUGS("AvNameCache") << "LLAvatarNameCache::requestNamesViaCapability requested "
+            << ids << " ids"
+            << LL_ENDL;
+
+        std::string coroname = 
+            LLCoros::instance().launch("LLAvatarNameCache::requestAvatarNameCache_",
+            boost::bind(&LLAvatarNameCache::requestAvatarNameCache_, _1, url, agent_ids));
+        LL_DEBUGS("AvNameCache") << coroname << " with  url '" << url << "', agent_ids.size()=" << agent_ids.size() << LL_ENDL;
+
 	}
 }
 
@@ -422,11 +479,20 @@ void LLAvatarNameCache::initClass(bool running, bool usePeopleAPI)
 {
 	sRunning = running;
 	sUsePeopleAPI = usePeopleAPI;
+
+    sHttpRequest = LLCore::HttpRequest::ptr_t(new LLCore::HttpRequest());
+    sHttpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false);
+    sHttpOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false);
+    sHttpPolicy = LLCore::HttpRequest::DEFAULT_POLICY_ID;
+    sHttpPriority = 0;
 }
 
 void LLAvatarNameCache::cleanupClass()
 {
-	sCache.clear();
+    sHttpRequest.reset();
+    sHttpHeaders.reset();
+    sHttpOptions.reset();
+    sCache.clear();
 }
 
 void LLAvatarNameCache::importFile(std::istream& istr)
@@ -498,6 +564,8 @@ void LLAvatarNameCache::idle()
 	// By convention, start running at first idle() call
 	sRunning = true;
 
+    sHttpRequest->update(0L);
+
 	// *TODO: Possibly re-enabled this based on People API load measurements
 	// 100 ms is the threshold for "user speed" operations, so we can
 	// stall for about that long to batch up requests.
@@ -697,6 +765,50 @@ void LLAvatarNameCache::insert(const LLUUID& agent_id, const LLAvatarName& av_na
 	sCache[agent_id] = av_name;
 }
 
+#if 0
+F64 LLAvatarNameCache::nameExpirationFromHeaders(LLCore::HttpHeaders *headers)
+{
+    F64 expires = 0.0;
+    if (expirationFromCacheControl(headers, &expires))
+    {
+        return expires;
+    }
+    else
+    {
+        // With no expiration info, default to an hour
+        const F64 DEFAULT_EXPIRES = 60.0 * 60.0;
+        F64 now = LLFrameTimer::getTotalSeconds();
+        return now + DEFAULT_EXPIRES;
+    }
+}
+
+bool LLAvatarNameCache::expirationFromCacheControl(LLCore::HttpHeaders *headers, F64 *expires)
+{
+    bool fromCacheControl = false;
+    F64 now = LLFrameTimer::getTotalSeconds();
+
+    // Allow the header to override the default
+    const std::string *cache_control;
+    
+    cache_control = headers->find(HTTP_IN_HEADER_CACHE_CONTROL);
+
+    if (cache_control && !cache_control->empty())
+    {
+        S32 max_age = 0;
+        if (max_age_from_cache_control(*cache_control, &max_age))
+        {
+            *expires = now + (F64)max_age;
+            fromCacheControl = true;
+        }
+    }
+    LL_DEBUGS("AvNameCache")
+        << ( fromCacheControl ? "expires based on cache control " : "default expiration " )
+        << "in " << *expires - now << " seconds"
+        << LL_ENDL;
+
+    return fromCacheControl;
+}
+#else
 F64 LLAvatarNameCache::nameExpirationFromHeaders(const LLSD& headers)
 {
 	F64 expires = 0.0;
@@ -741,7 +853,7 @@ bool LLAvatarNameCache::expirationFromCacheControl(const LLSD& headers, F64 *exp
 	
 	return fromCacheControl;
 }
-
+#endif
 
 void LLAvatarNameCache::addUseDisplayNamesCallback(const use_display_name_signal_t::slot_type& cb) 
 { 
diff --git a/indra/llmessage/llavatarnamecache.h b/indra/llmessage/llavatarnamecache.h
index ea016b3125..fdfd4e972d 100755
--- a/indra/llmessage/llavatarnamecache.h
+++ b/indra/llmessage/llavatarnamecache.h
@@ -29,7 +29,8 @@
 #define LLAVATARNAMECACHE_H
 
 #include "llavatarname.h"	// for convenience
-
+//#include "httpcommon.h"
+//#include "httpheaders.h"
 #include <boost/signals2.hpp>
 
 class LLSD;
@@ -49,7 +50,7 @@ namespace LLAvatarNameCache
 	void importFile(std::istream& istr);
 	void exportFile(std::ostream& ostr);
 
-	// On the viewer, usually a simulator capabilitity.
+	// On the viewer, usually a simulator capabilities.
 	// If empty, name cache will fall back to using legacy name lookup system.
 	void setNameLookupURL(const std::string& name_lookup_url);
 
@@ -90,7 +91,7 @@ namespace LLAvatarNameCache
 
 	// Compute name expiration time from HTTP Cache-Control header,
 	// or return default value, in seconds from epoch.
-	F64 nameExpirationFromHeaders(const LLSD& headers);
+    F64 nameExpirationFromHeaders(const LLSD& headers);
 
 	void addUseDisplayNamesCallback(const use_display_name_signal_t::slot_type& cb);
 }
diff --git a/indra/llmessage/llcorehttputil.cpp b/indra/llmessage/llcorehttputil.cpp
index 366a0b9460..991985b1cf 100644
--- a/indra/llmessage/llcorehttputil.cpp
+++ b/indra/llmessage/llcorehttputil.cpp
@@ -30,15 +30,17 @@
 #include <sstream>
 
 #include "llcorehttputil.h"
+#include "llhttpconstants.h"
 #include "llsdserialize.h"
 
-
 using namespace LLCore;
 
 
 namespace LLCoreHttpUtil
 {
 
+
+
 // *TODO:  Currently converts only from XML content.  A mode
 // to convert using fromBinary() might be useful as well.  Mesh
 // headers could use it.
@@ -186,5 +188,97 @@ std::string responseToString(LLCore::HttpResponse * response)
 }
 
 
+HttpCoroHandler::HttpCoroHandler(LLEventStream &reply) :
+    mReplyPump(reply)
+{
+}
+
+void HttpCoroHandler::onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response)
+{
+    LLSD result;
+
+    LLCore::HttpStatus status = response->getStatus();
+
+    if (!status)
+    {
+        result = LLSD::emptyMap();
+        LL_WARNS()
+            << "\n--------------------------------------------------------------------------\n"
+            << " Error[" << status.toULong() << "] cannot access url '" << response->getRequestURL() 
+            << "' because " << status.toString()
+            << "\n--------------------------------------------------------------------------"
+            << LL_ENDL;
+
+    }
+    else
+    {
+        const bool emit_parse_errors = false;
+
+        bool parsed = !((response->getBodySize() == 0) ||
+            !LLCoreHttpUtil::responseToLLSD(response, emit_parse_errors, result));
+
+        if (!parsed)
+        {
+            // Only emit a warning if we failed to parse when 'content-type' == 'application/llsd+xml'
+            LLCore::HttpHeaders::ptr_t headers(response->getHeaders());
+            const std::string *contentType = (headers) ? headers->find(HTTP_IN_HEADER_CONTENT_TYPE) : NULL;
+
+            if (contentType && (HTTP_CONTENT_LLSD_XML == *contentType))
+            {
+                std::string thebody = LLCoreHttpUtil::responseToString(response);
+                LL_WARNS() << "Failed to deserialize . " << response->getRequestURL() << " [status:" << response->getStatus().toString() << "] "
+                    << " body: " << thebody << LL_ENDL;
+
+                // Replace the status with a new one indicating the failure.
+                status = LLCore::HttpStatus(499, "Failed to deserialize LLSD.");
+            }
+        }
+
+        if (result.isUndefined())
+        {
+            // If we've gotten to this point and the result LLSD is still undefined 
+            // either there was an issue deserializing the body or the response was
+            // blank.  Create an empty map to hold the result either way.
+            result = LLSD::emptyMap();
+        }
+    }
+
+    buildStatusEntry(response, status, result);
+    mReplyPump.post(result);
+}
+
+void HttpCoroHandler::buildStatusEntry(LLCore::HttpResponse *response, LLCore::HttpStatus status, LLSD &result)
+{
+    LLSD httpresults = LLSD::emptyMap();
+
+    httpresults["success"] = static_cast<LLSD::Boolean>(status);
+    httpresults["type"] = static_cast<LLSD::Integer>(status.getType());
+    httpresults["status"] = static_cast<LLSD::Integer>(status.getStatus());
+    httpresults["message"] = static_cast<LLSD::String>(status.getMessage());
+    httpresults["url"] = static_cast<LLSD::String>(response->getRequestURL());
+
+    LLSD httpHeaders = LLSD::emptyMap();
+    LLCore::HttpHeaders * hdrs = response->getHeaders();
+
+    if (hdrs)
+    {
+        for (LLCore::HttpHeaders::iterator it = hdrs->begin(); it != hdrs->end(); ++it)
+        {
+            if (!(*it).second.empty())
+            {
+                httpHeaders[(*it).first] = (*it).second;
+            }
+            else
+            {
+                httpHeaders[(*it).first] = static_cast<LLSD::Boolean>(true);
+            }
+        }
+    }
+
+    httpresults["headers"] = httpHeaders;
+    result["http_result"] = httpresults;
+}
+
+
 } // end namespace LLCoreHttpUtil
 
diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 8e26f413fe..0bc102a0a3 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -39,6 +39,7 @@
 #include "bufferarray.h"
 #include "bufferstream.h"
 #include "llsd.h"
+#include "llevents.h"
 
 ///
 /// The base llcorehttp library implements many HTTP idioms
@@ -152,6 +153,35 @@ LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
 	LLCore::HttpHeaders::ptr_t & headers,
 	LLCore::HttpHandler * handler);
 
+/// The HttpCoroHandler is a specialization of the LLCore::HttpHandler for 
+/// interacting with coroutines. When the request is completed the response 
+/// will be posted onto the supplied Event Pump.
+/// 
+/// The LLSD posted back to the coroutine will have the following additions:
+/// llsd["http_result"] -+- ["message"] - An error message returned from the HTTP status
+///                      +- ["status"]  - The status code associated with the HTTP call
+///                      +- ["success"] - Success of failure of the HTTP call and LLSD parsing.
+///                      +- ["type"]    - The LLCore::HttpStatus type associted with the HTTP call
+///                      +- ["url"]     - The URL used to make the call.
+///                      +- ["headers"] - A map of name name value pairs with the HTTP headers.
+///                      
+
+/// 
+class HttpCoroHandler : public LLCore::HttpHandler
+{
+public:
+    HttpCoroHandler(LLEventStream &reply);
+
+    virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);
+
+    typedef boost::shared_ptr<HttpCoroHandler> ptr_t;
+
+private:
+    void buildStatusEntry(LLCore::HttpResponse *response, LLCore::HttpStatus status, LLSD &result);
+
+    LLEventStream &mReplyPump;
+};
+
 } // end namespace LLCoreHttpUtil
 
 
diff --git a/indra/llmessage/llhttpsdhandler.cpp b/indra/llmessage/llhttpsdhandler.cpp
index 72ecfe77e2..159d03b176 100644
--- a/indra/llmessage/llhttpsdhandler.cpp
+++ b/indra/llmessage/llhttpsdhandler.cpp
@@ -36,10 +36,8 @@
 #include "llcorehttputil.h"
 
 //========================================================================
-LLHttpSDHandler::LLHttpSDHandler(const LLURI &uri):
-	mUri(uri)
+LLHttpSDHandler::LLHttpSDHandler()
 {
-
 }
 
 void LLHttpSDHandler::onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response)
@@ -68,7 +66,7 @@ void LLHttpSDHandler::onCompleted(LLCore::HttpHandle handle, LLCore::HttpRespons
 			{
 				std::string thebody = LLCoreHttpUtil::responseToString(response);
 
-				LL_WARNS() << "Failed to deserialize . " << getUri() << " [status:" << response->getStatus().toString() << "] "
+				LL_WARNS() << "Failed to deserialize . " << response->getRequestURL() << " [status:" << response->getStatus().toString() << "] "
 					<< " body: " << thebody << LL_ENDL;
 			}
 		}
@@ -83,8 +81,8 @@ void LLHttpSDHandler::onCompleted(LLCore::HttpHandle handle, LLCore::HttpRespons
 }
 
 //========================================================================
-LLHttpSDGenericHandler::LLHttpSDGenericHandler(const LLURI &uri, const std::string &caps) :
-	LLHttpSDHandler(uri),
+LLHttpSDGenericHandler::LLHttpSDGenericHandler(const std::string &caps) :
+	LLHttpSDHandler(),
 	mCaps(caps)
 {
 }
@@ -99,7 +97,7 @@ void LLHttpSDGenericHandler::onFailure(LLCore::HttpResponse * response, LLCore::
 	LL_WARNS()
 		<< "\n--------------------------------------------------------------------------\n"
 		<< mCaps << " Error[" << status.toULong() << "] cannot access cap with url '" 
-		<< getUri() << "' because " << status.toString()
+		<< response->getRequestURL() << "' because " << status.toString()
 		<< "\n--------------------------------------------------------------------------"
 		<< LL_ENDL;
 }
diff --git a/indra/llmessage/llhttpsdhandler.h b/indra/llmessage/llhttpsdhandler.h
index a2598c9709..7c28dbcab6 100644
--- a/indra/llmessage/llhttpsdhandler.h
+++ b/indra/llmessage/llhttpsdhandler.h
@@ -39,21 +39,14 @@
 class LLHttpSDHandler : public LLCore::HttpHandler
 {
 public:
-	LLHttpSDHandler(const LLURI &uri);
+	LLHttpSDHandler();
 
 	virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);
 	
-	inline const LLURI &getUri() const
-	{
-		return mUri;
-	}
-
 protected:
 	virtual void onSuccess(LLCore::HttpResponse * response, const LLSD &content) = 0;
 	virtual void onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status) = 0;
 
-private:
-	LLURI	mUri;
 };
 
 /// A trivial implementation of LLHttpSDHandler. This success and failure 
@@ -62,7 +55,7 @@ private:
 class LLHttpSDGenericHandler : public LLHttpSDHandler
 {
 public: 
-	LLHttpSDGenericHandler(const LLURI &uri, const std::string &action);
+	LLHttpSDGenericHandler(const std::string &action);
 
 protected:
 	virtual void onSuccess(LLCore::HttpResponse * response, const LLSD &content);
diff --git a/indra/newview/llagent.cpp b/indra/newview/llagent.cpp
index 667d530e39..eeedda5c6d 100755
--- a/indra/newview/llagent.cpp
+++ b/indra/newview/llagent.cpp
@@ -325,7 +325,6 @@ bool LLAgent::isMicrophoneOn(const LLSD& sdname)
 // For a toggled version, see viewer.h for the
 // TOGGLE_HACKED_GODLIKE_VIEWER define, instead.
 // ************************************************************
-bool LLAgent::mActive = true;
 
 // Constructors and Destructors
 
@@ -474,7 +473,9 @@ void LLAgent::init()
 	mHttpOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false);
 	mHttpPolicy = app_core_http.getPolicy(LLAppCoreHttp::AP_AGENT);
 
-	doOnIdleRepeating(boost::bind(&LLAgent::onIdle, this));
+    // Now ensure that we get regular callbacks to poll for completion.
+    mBoundListener = LLEventPumps::instance().obtain("mainloop").
+        listen(LLEventPump::inventName(), boost::bind(&LLAgent::pollHttp, this, _1));
 
 	mInitialized = TRUE;
 }
@@ -484,7 +485,6 @@ void LLAgent::init()
 //-----------------------------------------------------------------------------
 void LLAgent::cleanup()
 {
-	mActive = false;
 	mRegionp = NULL;
 	if (mTeleportFinishedSlot.connected())
 	{
@@ -494,6 +494,10 @@ void LLAgent::cleanup()
 	{
 		mTeleportFailedSlot.disconnect();
 	}
+    if (mBoundListener.connected())
+    {
+        mBoundListener.disconnect();
+    }
 }
 
 //-----------------------------------------------------------------------------
@@ -517,16 +521,16 @@ LLAgent::~LLAgent()
 }
 
 //-----------------------------------------------------------------------------
-// Idle processing
+// pollHttp
+//  Polling done once per frame on the "mainloop" to support HTTP processing.
 //-----------------------------------------------------------------------------
-bool LLAgent::onIdle()
+bool LLAgent::pollHttp(const LLSD&)
 {
-	if (!LLAgent::mActive)
-		return true;
-	mHttpRequest->update(0L);
-	return false;
+    mHttpRequest->update(0L);
+    return false;
 }
 
+
 // Handle any actions that need to be performed when the main app gains focus
 // (such as through alt-tab).
 //-----------------------------------------------------------------------------
@@ -2548,8 +2552,8 @@ int LLAgent::convertTextToMaturity(char text)
 class LLMaturityHttpHandler : public LLHttpSDHandler
 {
 public:
-	LLMaturityHttpHandler(const std::string& capabilityURL, LLAgent *agent, U8 preferred, U8 previous):
-		LLHttpSDHandler(capabilityURL),
+	LLMaturityHttpHandler(LLAgent *agent, U8 preferred, U8 previous):
+		LLHttpSDHandler(),
 		mAgent(agent),
 		mPreferredMaturity(preferred),
 		mPreviousMaturity(previous)
@@ -2764,7 +2768,7 @@ void LLAgent::sendMaturityPreferenceToServer(U8 pPreferredMaturity)
 			return;
 		}
 
-		LLMaturityHttpHandler * handler = new LLMaturityHttpHandler(url, this, pPreferredMaturity, mLastKnownResponseMaturity);
+		LLMaturityHttpHandler * handler = new LLMaturityHttpHandler(this, pPreferredMaturity, mLastKnownResponseMaturity);
 
 		LLSD access_prefs = LLSD::emptyMap();
 		access_prefs["max"] = LLViewerRegion::accessToShortString(pPreferredMaturity);
@@ -2779,14 +2783,14 @@ void LLAgent::sendMaturityPreferenceToServer(U8 pPreferredMaturity)
 		if (handle == LLCORE_HTTP_HANDLE_INVALID)
 		{
 			delete handler;
-			LL_WARNS("Avatar") << "Maturity request post failed." << LL_ENDL;
+			LL_WARNS("Agent") << "Maturity request post failed." << LL_ENDL;
 		}
 	}
 }
 
 LLCore::HttpHandle LLAgent::requestPostCapability(const std::string &cap, const std::string &url, LLSD &postData, LLHttpSDHandler *usrhndlr)
 {
-	LLHttpSDHandler * handler = (usrhndlr) ? usrhndlr : new LLHttpSDGenericHandler(url, cap);
+	LLHttpSDHandler * handler = (usrhndlr) ? usrhndlr : new LLHttpSDGenericHandler(cap);
 	LLCore::HttpHandle handle = LLCoreHttpUtil::requestPostWithLLSD(mHttpRequest,
 		mHttpPolicy, mHttpPriority, url,
 		postData, mHttpOptions, mHttpHeaders, handler);
@@ -2799,16 +2803,31 @@ LLCore::HttpHandle LLAgent::requestPostCapability(const std::string &cap, const
 		if (!usrhndlr)
 			delete handler;
 		LLCore::HttpStatus status = mHttpRequest->getStatus();
-		LL_WARNS("Avatar") << "'" << cap << "' request POST failed. Reason " 
+		LL_WARNS("Agent") << "'" << cap << "' request POST failed. Reason " 
 			<< status.toTerseString() << " \"" << status.toString() << "\"" << LL_ENDL;
 	}
 	return handle;
 }
 
-//LLCore::HttpHandle LLAgent::httpGetCapibility(const std::string &cap, const LLURI &uri, LLHttpSDHandler *usrhndlr)
-//{
-//}
+LLCore::HttpHandle LLAgent::requestGetCapability(const std::string &cap, const std::string &url, LLHttpSDHandler *usrhndlr)
+{
+    LLHttpSDHandler * handler = (usrhndlr) ? usrhndlr : new LLHttpSDGenericHandler(cap);
+    LLCore::HttpHandle handle = mHttpRequest->requestGet(mHttpPolicy, mHttpPriority, 
+            url, mHttpOptions.get(), mHttpHeaders.get(), handler);
 
+    if (handle == LLCORE_HTTP_HANDLE_INVALID)
+    {
+        // If no handler was passed in we delete the handler default handler allocated 
+        // at the start of this function.
+        // *TODO: Change this metaphore to use boost::shared_ptr<> for handlers.  Requires change in LLCore::HTTP
+        if (!usrhndlr)
+            delete handler;
+        LLCore::HttpStatus status = mHttpRequest->getStatus();
+        LL_WARNS("Agent") << "'" << cap << "' request GET failed. Reason "
+            << status.toTerseString() << " \"" << status.toString() << "\"" << LL_ENDL;
+    }
+    return handle;
+}
 
 BOOL LLAgent::getAdminOverride() const	
 { 
diff --git a/indra/newview/llagent.h b/indra/newview/llagent.h
index 26120b52f6..9ffc9b9a7a 100755
--- a/indra/newview/llagent.h
+++ b/indra/newview/llagent.h
@@ -34,6 +34,7 @@
 #include "llcoordframe.h"			// for mFrameAgent
 #include "llavatarappearancedefines.h"
 #include "llpermissionsflags.h"
+#include "llevents.h"
 #include "v3dmath.h"
 #include "httprequest.h"
 #include "httpheaders.h"
@@ -117,9 +118,7 @@ public:
 	void			cleanup();
 
 private:
-	bool			onIdle();
 
-	static bool		mActive;
 	//--------------------------------------------------------------------
 	// Login
 	//--------------------------------------------------------------------
@@ -767,6 +766,7 @@ private:
 	LLCore::HttpOptions::ptr_t		mHttpOptions;
 	LLCore::HttpRequest::policy_t	mHttpPolicy;
 	LLCore::HttpRequest::priority_t	mHttpPriority;
+    LLTempBoundListener             mBoundListener;
 
 	bool            isMaturityPreferenceSyncedWithServer() const;
 	void 			sendMaturityPreferenceToServer(U8 pPreferredMaturity);
@@ -781,6 +781,8 @@ private:
 	void 			handleMaturity(const LLSD &pNewValue);
 	bool 			validateMaturity(const LLSD& newvalue);
 
+    bool            pollHttp(const LLSD &);
+
 
 /**                    Access
  **                                                                            **
@@ -924,9 +926,9 @@ public:
  **/
 public:
 	/// Utilities for allowing the the agent sub managers to post and get via
-	/// HTTP using the agent's policy settings and headers.
+	/// HTTP using the agent's policy settings and headers.  
 	LLCore::HttpHandle	requestPostCapability(const std::string &cap, const std::string &url, LLSD &postData, LLHttpSDHandler *usrhndlr = NULL);
-	//LLCore::HttpHandle	httpGetCapability(const std::string &cap, const LLURI &uri, LLHttpSDHandler *usrhndlr = NULL);
+    LLCore::HttpHandle	requestGetCapability(const std::string &cap, const std::string &url, LLHttpSDHandler *usrhndlr = NULL);
 
 /**                    Utility
  **                                                                            **
diff --git a/indra/newview/llappearancemgr.cpp b/indra/newview/llappearancemgr.cpp
index 709d9881e1..4fbcd90baa 100755
--- a/indra/newview/llappearancemgr.cpp
+++ b/indra/newview/llappearancemgr.cpp
@@ -1249,8 +1249,8 @@ static void removeDuplicateItems(LLInventoryModel::item_array_t& items)
 class LLAppearanceMgrHttpHandler : public LLHttpSDHandler
 {
 public:
-	LLAppearanceMgrHttpHandler(const std::string& capabilityURL, LLAppearanceMgr *mgr) :
-		LLHttpSDHandler(capabilityURL),
+	LLAppearanceMgrHttpHandler(LLAppearanceMgr *mgr) :
+		LLHttpSDHandler(),
 		mManager(mgr)
 	{ }
 
@@ -1314,7 +1314,7 @@ void LLAppearanceMgrHttpHandler::onSuccess(LLCore::HttpResponse * response, cons
 
 void LLAppearanceMgrHttpHandler::onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status)
 {
-	LL_WARNS("Avatar") << "Appearance Mgr request failed to " << getUri()
+	LL_WARNS("Avatar") << "Appearance Mgr request failed to " << response->getRequestURL()
 		<< ". Reason code: (" << status.toTerseString() << ") "
 		<< status.toString() << LL_ENDL;
 }
@@ -3434,7 +3434,7 @@ void LLAppearanceMgr::requestServerAppearanceUpdate()
 	}
 	LL_DEBUGS("Avatar") << "request url " << url << " my_cof_version " << cof_version << LL_ENDL;
 
-	LLAppearanceMgrHttpHandler * handler = new LLAppearanceMgrHttpHandler(url, this);
+	LLAppearanceMgrHttpHandler * handler = new LLAppearanceMgrHttpHandler(this);
 
 	mInFlightCounter++;
 	mInFlightTimer.setTimerExpirySec(60.0);
diff --git a/indra/newview/llmaterialmgr.cpp b/indra/newview/llmaterialmgr.cpp
index 78fbe9af0a..8a726ec7c9 100755
--- a/indra/newview/llmaterialmgr.cpp
+++ b/indra/newview/llmaterialmgr.cpp
@@ -70,7 +70,7 @@ public:
 	typedef boost::function<void(bool, const LLSD&)> CallbackFunction;
 	typedef boost::shared_ptr<LLMaterialHttpHandler> ptr_t;
 
-	LLMaterialHttpHandler(const std::string& method, const std::string& capabilityURL, CallbackFunction cback);
+	LLMaterialHttpHandler(const std::string& method, CallbackFunction cback);
 
 	virtual ~LLMaterialHttpHandler();
 
@@ -83,8 +83,8 @@ private:
 	CallbackFunction mCallback;
 };
 
-LLMaterialHttpHandler::LLMaterialHttpHandler(const std::string& method, const std::string& capabilityURL, CallbackFunction cback):
-	LLHttpSDHandler(capabilityURL),
+LLMaterialHttpHandler::LLMaterialHttpHandler(const std::string& method, CallbackFunction cback):
+	LLHttpSDHandler(),
 	mMethod(method),
 	mCallback(cback)
 {
@@ -106,7 +106,7 @@ void LLMaterialHttpHandler::onFailure(LLCore::HttpResponse * response, LLCore::H
 	LL_WARNS("Materials")
 		<< "\n--------------------------------------------------------------------------\n"
 		<< mMethod << " Error[" << status.toULong() << "] cannot access cap '" << MATERIALS_CAPABILITY_NAME
-		<< "'\n  with url '" << getUri() << "' because " << status.toString()
+		<< "'\n  with url '" << response->getRequestURL() << "' because " << status.toString()
 		<< "\n--------------------------------------------------------------------------"
 		<< LL_ENDL;
 
@@ -653,7 +653,7 @@ void LLMaterialMgr::processGetQueue()
 		postData[MATERIALS_CAP_ZIP_FIELD] = materialBinary;
 
 		LLMaterialHttpHandler * handler = 
-				new LLMaterialHttpHandler("POST", capURL,
+				new LLMaterialHttpHandler("POST",
 				boost::bind(&LLMaterialMgr::onGetResponse, this, _1, _2, region_id)
 				);
 
@@ -707,7 +707,7 @@ void LLMaterialMgr::processGetAllQueue()
 
 		LL_DEBUGS("Materials") << "GET all for region " << region_id << "url " << capURL << LL_ENDL;
 		LLMaterialHttpHandler *handler = 
-			new LLMaterialHttpHandler("GET", capURL,
+			new LLMaterialHttpHandler("GET",
 			boost::bind(&LLMaterialMgr::onGetAllResponse, this, _1, _2, *itRegion)
 			);
 
@@ -810,7 +810,7 @@ void LLMaterialMgr::processPutQueue()
 			LL_DEBUGS("Materials") << "put for " << itRequest->second.size() << " faces to region " << itRequest->first->getName() << LL_ENDL;
 
 			LLMaterialHttpHandler * handler =
-					new LLMaterialHttpHandler("PUT", capURL,
+					new LLMaterialHttpHandler("PUT",
 					boost::bind(&LLMaterialMgr::onPutResponse, this, _1, _2)
 					);
 
-- 
cgit v1.3


From 1c91c8a106a78f2087a3fb4312e428a0128283b4 Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Wed, 8 Apr 2015 10:17:34 -0700
Subject: Adding weak pointer support. Event polling as a coroutine.
 (incomplete) Groundwork for canceling HttpCoroutineAdapter yields.

---
 indra/llcorehttp/httpcommon.h      |   1 +
 indra/llcorehttp/httprequest.h     |   1 +
 indra/llmessage/llcorehttputil.cpp |  81 ++---
 indra/llmessage/llcorehttputil.h   |  30 +-
 indra/newview/lleventpoll.cpp      | 688 ++++++++++++++++++++++++-------------
 indra/newview/lleventpoll.h        |  17 +-
 6 files changed, 524 insertions(+), 294 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/httpcommon.h b/indra/llcorehttp/httpcommon.h
index ada5c1bbe7..898d3d47fa 100755
--- a/indra/llcorehttp/httpcommon.h
+++ b/indra/llcorehttp/httpcommon.h
@@ -190,6 +190,7 @@
 #include "linden_common.h"		// Modifies curl/curl.h interfaces
 #include "boost/intrusive_ptr.hpp"
 #include "boost/shared_ptr.hpp"
+#include "boost/weak_ptr.hpp"
 #include "boost/function.hpp"
 #include <string>
 
diff --git a/indra/llcorehttp/httprequest.h b/indra/llcorehttp/httprequest.h
index f7ce82d412..6688f06eb5 100755
--- a/indra/llcorehttp/httprequest.h
+++ b/indra/llcorehttp/httprequest.h
@@ -98,6 +98,7 @@ public:
 	typedef unsigned int priority_t;
 	
 	typedef boost::shared_ptr<HttpRequest> ptr_t;
+    typedef boost::weak_ptr<HttpRequest>   wptr_t;
 public:
 	/// @name PolicyMethods
 	/// @{
diff --git a/indra/llmessage/llcorehttputil.cpp b/indra/llmessage/llcorehttputil.cpp
index 882fef66bc..d560ec8462 100644
--- a/indra/llmessage/llcorehttputil.cpp
+++ b/indra/llmessage/llcorehttputil.cpp
@@ -317,15 +317,18 @@ HttpCoroutineAdapter::HttpCoroutineAdapter(const std::string &name,
     LLCore::HttpRequest::policy_t policyId, LLCore::HttpRequest::priority_t priority) :
     mAdapterName(name),
     mPolicyId(policyId),
-    mPriority(priority)
+    mPriority(priority),
+    mYieldingHandle(LLCORE_HTTP_HANDLE_INVALID),
+    mWeakRequest()
 {
 }
 
 HttpCoroutineAdapter::~HttpCoroutineAdapter()
 {
+
 }
 
-LLSD HttpCoroutineAdapter::postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+LLSD HttpCoroutineAdapter::postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
     const std::string & url, const LLSD & body,
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
@@ -353,28 +356,17 @@ LLSD HttpCoroutineAdapter::postAndYield(LLCoros::self & self, LLCore::HttpReques
 
     if (hhandle == LLCORE_HTTP_HANDLE_INVALID)
     {
-        LLCore::HttpStatus status = request->getStatus();
-        LL_WARNS() << "Error posting to " << url << " Status=" << status.getStatus() <<
-            " message = " << status.getMessage() << LL_ENDL;
-
-        // Mimic the status results returned from an http error that we had 
-        // to wait on 
-        LLSD httpresults = LLSD::emptyMap();
-
-        httpHandler->writeStatusCodes(status, url, httpresults);
-
-        LLSD errorres = LLSD::emptyMap();
-        errorres["http_result"] = httpresults;
-
-        return errorres;
+        return HttpCoroutineAdapter::buildImmediateErrorResult(request, url, httpHandler);
     }
 
+    mYieldingHandle = hhandle;
     LLSD results = waitForEventOn(self, replyPump);
+    mYieldingHandle = LLCORE_HTTP_HANDLE_INVALID;
     //LL_INFOS() << "Results for transaction " << transactionId << LL_ENDL;
     return results;
 }
 
-LLSD HttpCoroutineAdapter::putAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t & request,
+LLSD HttpCoroutineAdapter::putAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
     const std::string & url, const LLSD & body,
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
@@ -402,28 +394,17 @@ LLSD HttpCoroutineAdapter::putAndYield(LLCoros::self & self, LLCore::HttpRequest
 
     if (hhandle == LLCORE_HTTP_HANDLE_INVALID)
     {
-        LLCore::HttpStatus status = request->getStatus();
-        LL_WARNS() << "Error posting to " << url << " Status=" << status.getStatus() <<
-            " message = " << status.getMessage() << LL_ENDL;
-
-        // Mimic the status results returned from an http error that we had 
-        // to wait on 
-        LLSD httpresults = LLSD::emptyMap();
-
-        httpHandler->writeStatusCodes(status, url, httpresults);
-
-        LLSD errorres = LLSD::emptyMap();
-        errorres["http_result"] = httpresults;
-
-        return errorres;
+        return HttpCoroutineAdapter::buildImmediateErrorResult(request, url, httpHandler);
     }
 
+    mYieldingHandle = hhandle;
     LLSD results = waitForEventOn(self, replyPump);
+    mYieldingHandle = LLCORE_HTTP_HANDLE_INVALID;
     //LL_INFOS() << "Results for transaction " << transactionId << LL_ENDL;
     return results;
 }
 
-LLSD HttpCoroutineAdapter::getAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t & request,
+LLSD HttpCoroutineAdapter::getAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
     const std::string & url,
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
@@ -450,26 +431,34 @@ LLSD HttpCoroutineAdapter::getAndYield(LLCoros::self & self, LLCore::HttpRequest
 
     if (hhandle == LLCORE_HTTP_HANDLE_INVALID)
     {
-        LLCore::HttpStatus status = request->getStatus();
-        LL_WARNS() << "Error posting to " << url << " Status=" << status.getStatus() <<
-            " message = " << status.getMessage() << LL_ENDL;
-
-        // Mimic the status results returned from an http error that we had 
-        // to wait on 
-        LLSD httpresults = LLSD::emptyMap();
-
-        httpHandler->writeStatusCodes(status, url, httpresults);
-
-        LLSD errorres = LLSD::emptyMap();
-        errorres["http_result"] = httpresults;
-
-        return errorres;
+        return HttpCoroutineAdapter::buildImmediateErrorResult(request, url, httpHandler);
     }
 
+    mYieldingHandle = hhandle;
     LLSD results = waitForEventOn(self, replyPump);
+    mYieldingHandle = LLCORE_HTTP_HANDLE_INVALID;
     //LL_INFOS() << "Results for transaction " << transactionId << LL_ENDL;
     return results;
 }
 
+LLSD HttpCoroutineAdapter::buildImmediateErrorResult(const LLCore::HttpRequest::ptr_t &request, 
+    const std::string &url, LLCoreHttpUtil::HttpCoroHandler::ptr_t &httpHandler) 
+{
+    LLCore::HttpStatus status = request->getStatus();
+    LL_WARNS() << "Error posting to " << url << " Status=" << status.getStatus() <<
+        " message = " << status.getMessage() << LL_ENDL;
+
+    // Mimic the status results returned from an http error that we had 
+    // to wait on 
+    LLSD httpresults = LLSD::emptyMap();
+
+    httpHandler->writeStatusCodes(status, url, httpresults);
+
+    LLSD errorres = LLSD::emptyMap();
+    errorres["http_result"] = httpresults;
+
+    return errorres;
+}
+
 } // end namespace LLCoreHttpUtil
 
diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 10f46dd477..33cc389c49 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -210,36 +210,54 @@ private:
 class HttpCoroutineAdapter
 {
 public:
+    typedef boost::shared_ptr<HttpCoroutineAdapter> ptr_t;
+    typedef boost::weak_ptr<HttpCoroutineAdapter>   wptr_t;
+
     HttpCoroutineAdapter(const std::string &name, LLCore::HttpRequest::policy_t policyId, 
             LLCore::HttpRequest::priority_t priority = 0L);
     ~HttpCoroutineAdapter();
 
     /// Execute a Post transaction on the supplied URL and yield execution of 
-    /// the coroutine until a result is available.
-    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t & request,
+    /// the coroutine until a result is available. 
+    /// Note: the request's smart pointer is passed by value so that it will
+    /// not be deallocated during the yield.
+    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body, 
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(), 
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t());
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
 
     /// Execute a Put transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available.
-    LLSD putAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t & request,
+    /// Note: the request's smart pointer is passed by value so that it will
+    /// not be deallocated during the yield.
+    LLSD putAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t());
 
     /// Execute a Get transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available.
-    LLSD getAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t & request,
+    /// Note: the request's smart pointer is passed by value so that it will
+    /// not be deallocated during the yield.
+    LLSD getAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t());
 
+    ///
+    void cancelYieldingOperation();
+
 private:
+    static LLSD buildImmediateErrorResult(const LLCore::HttpRequest::ptr_t &request, 
+            const std::string &url, LLCoreHttpUtil::HttpCoroHandler::ptr_t &httpHandler);
 
     std::string                     mAdapterName;
     LLCore::HttpRequest::priority_t mPriority;
     LLCore::HttpRequest::policy_t   mPolicyId;
+
+    LLCore::HttpHandle              mYieldingHandle;
+    LLCore::HttpRequest::wptr_t     mWeakRequest;
+
 };
 
 } // end namespace LLCoreHttpUtil
diff --git a/indra/newview/lleventpoll.cpp b/indra/newview/lleventpoll.cpp
index 4de6ad4d2f..493ee06083 100755
--- a/indra/newview/lleventpoll.cpp
+++ b/indra/newview/lleventpoll.cpp
@@ -37,254 +37,460 @@
 #include "llviewerregion.h"
 #include "message.h"
 #include "lltrans.h"
+#include "llcoros.h"
+#include "lleventcoro.h"
+#include "llcorehttputil.h"
 
 namespace
 {
-	// We will wait RETRY_SECONDS + (errorCount * RETRY_SECONDS_INC) before retrying after an error.
-	// This means we attempt to recover relatively quickly but back off giving more time to recover
-	// until we finally give up after MAX_EVENT_POLL_HTTP_ERRORS attempts.
-	const F32 EVENT_POLL_ERROR_RETRY_SECONDS = 15.f; // ~ half of a normal timeout.
-	const F32 EVENT_POLL_ERROR_RETRY_SECONDS_INC = 5.f; // ~ half of a normal timeout.
-	const S32 MAX_EVENT_POLL_HTTP_ERRORS = 10; // ~5 minutes, by the above rules.
-
-	class LLEventPollResponder : public LLHTTPClient::Responder
-	{
-		LOG_CLASS(LLEventPollResponder);
-	public:
-		
-		static LLHTTPClient::ResponderPtr start(const std::string& pollURL, const LLHost& sender);
-		void stop();
-		
-		void makeRequest();
-
-		/* virtual */ void completedRaw(const LLChannelDescriptors& channels,
-								  const LLIOPipe::buffer_ptr_t& buffer);
-
-	private:
-		LLEventPollResponder(const std::string&	pollURL, const LLHost& sender);
-		~LLEventPollResponder();
-
-		
-		void handleMessage(const LLSD& content);
-
-		/* virtual */ void httpFailure();
-		/* virtual */ void httpSuccess();
-
-	private:
-
-		bool	mDone;
-
-		std::string			mPollURL;
-		std::string			mSender;
-		
-		LLSD	mAcknowledge;
-		
-		// these are only here for debugging so	we can see which poller	is which
-		static int sCount;
-		int	mCount;
-		S32 mErrorCount;
-	};
-
-	class LLEventPollEventTimer : public LLEventTimer
-	{
-		typedef LLPointer<LLEventPollResponder> EventPollResponderPtr;
-
-	public:
-		LLEventPollEventTimer(F32 period, EventPollResponderPtr responder)
-			: LLEventTimer(period), mResponder(responder)
-		{ }
-
-		virtual BOOL tick()
-		{
-			mResponder->makeRequest();
-			return TRUE;	// Causes this instance to be deleted.
-		}
-
-	private:
-		
-		EventPollResponderPtr mResponder;
-	};
-
-	//static
-	LLHTTPClient::ResponderPtr LLEventPollResponder::start(
-		const std::string& pollURL, const LLHost& sender)
-	{
-		LLHTTPClient::ResponderPtr result = new LLEventPollResponder(pollURL, sender);
-		LL_INFOS()	<< "LLEventPollResponder::start <" << sCount << "> "
-				<< pollURL << LL_ENDL;
-		return result;
-	}
-
-	void LLEventPollResponder::stop()
-	{
-		LL_INFOS()	<< "LLEventPollResponder::stop	<" << mCount <<	"> "
-				<< mPollURL	<< LL_ENDL;
-		// there should	be a way to	stop a LLHTTPClient	request	in progress
-		mDone =	true;
-	}
-
-	int	LLEventPollResponder::sCount =	0;
-
-	LLEventPollResponder::LLEventPollResponder(const std::string& pollURL, const LLHost& sender)
-		: mDone(false),
-		  mPollURL(pollURL),
-		  mCount(++sCount),
-		  mErrorCount(0)
-	{
-		//extract host and port of simulator to set as sender
-		LLViewerRegion *regionp = gAgent.getRegion();
-		if (!regionp)
-		{
-			LL_ERRS() << "LLEventPoll initialized before region is added." << LL_ENDL;
-		}
-		mSender = sender.getIPandPort();
-		LL_INFOS() << "LLEventPoll initialized with sender " << mSender << LL_ENDL;
-		makeRequest();
-	}
-
-	LLEventPollResponder::~LLEventPollResponder()
-	{
-		stop();
-		LL_DEBUGS() <<	"LLEventPollResponder::~Impl <" <<	mCount << "> "
-				 <<	mPollURL <<	LL_ENDL;
-	}
-
-	// virtual 
-	void LLEventPollResponder::completedRaw(const LLChannelDescriptors& channels,
-											const LLIOPipe::buffer_ptr_t& buffer)
-	{
-		if (getStatus() == HTTP_BAD_GATEWAY)
-		{
-			// These errors are not parsable as LLSD, 
-			// which LLHTTPClient::Responder::completedRaw will try to do.
-			httpCompleted();
-		}
-		else
-		{
-			LLHTTPClient::Responder::completedRaw(channels,buffer);
-		}
-	}
-
-	void LLEventPollResponder::makeRequest()
-	{
-		LLSD request;
-		request["ack"] = mAcknowledge;
-		request["done"]	= mDone;
-		
-		LL_DEBUGS() <<	"LLEventPollResponder::makeRequest	<" << mCount <<	"> ack = "
-				 <<	LLSDXMLStreamer(mAcknowledge) << LL_ENDL;
-		LLHTTPClient::post(mPollURL, request, this);
-	}
-
-	void LLEventPollResponder::handleMessage(const	LLSD& content)
-	{
-		std::string	msg_name	= content["message"];
-		LLSD message;
-		message["sender"] = mSender;
-		message["body"] = content["body"];
-		LLMessageSystem::dispatch(msg_name, message);
-	}
-
-	//virtual
-	void LLEventPollResponder::httpFailure()
-	{
-		if (mDone) return;
-
-		// A HTTP_BAD_GATEWAY (502) error is our standard timeout response
-		// we get this when there are no events.
-		if ( getStatus() == HTTP_BAD_GATEWAY )
-		{
-			mErrorCount = 0;
-			makeRequest();
-		}
-		else if (mErrorCount < MAX_EVENT_POLL_HTTP_ERRORS)
-		{
-			++mErrorCount;
-			
-			// The 'tick' will return TRUE causing the timer to delete this.
-			new LLEventPollEventTimer(EVENT_POLL_ERROR_RETRY_SECONDS
-										+ mErrorCount * EVENT_POLL_ERROR_RETRY_SECONDS_INC
-									, this);
-
-			LL_WARNS() << dumpResponse() << LL_ENDL;
-		}
-		else
-		{
-			LL_WARNS() << dumpResponse()
-					   << " [count:" << mCount << "] "
-					   << (mDone ? " -- done" : "") << LL_ENDL;
-			stop();
-
-			// At this point we have given up and the viewer will not receive HTTP messages from the simulator.
-			// IMs, teleports, about land, selecing land, region crossing and more will all fail.
-			// They are essentially disconnected from the region even though some things may still work.
-			// Since things won't get better until they relog we force a disconnect now.
-
-			// *NOTE:Mani - The following condition check to see if this failing event poll
-			// is attached to the Agent's main region. If so we disconnect the viewer.
-			// Else... its a child region and we just leave the dead event poll stopped and 
-			// continue running.
-			if(gAgent.getRegion() && gAgent.getRegion()->getHost().getIPandPort() == mSender)
-			{
-				LL_WARNS() << "Forcing disconnect due to stalled main region event poll."  << LL_ENDL;
-				LLAppViewer::instance()->forceDisconnect(LLTrans::getString("AgentLostConnection"));
-			}
-		}
-	}
-
-	//virtual
-	void LLEventPollResponder::httpSuccess()
-	{
-		LL_DEBUGS() <<	"LLEventPollResponder::result <" << mCount	<< ">"
-				 <<	(mDone ? " -- done"	: "") << LL_ENDL;
-		
-		if (mDone) return;
-
-		mErrorCount = 0;
-
-		const LLSD& content = getContent();
-		if (!content.isMap() ||
-			!content.get("events") ||
-			!content.get("id"))
-		{
-			LL_WARNS() << "received event poll with no events or id key: " << dumpResponse() << LL_ENDL;
-			makeRequest();
-			return;
-		}
-		
-		mAcknowledge = content["id"];
-		LLSD events	= content["events"];
-
-		if(mAcknowledge.isUndefined())
-		{
-			LL_WARNS() << "LLEventPollResponder: id undefined" << LL_ENDL;
-		}
-		
-		// was LL_INFOS() but now that CoarseRegionUpdate is TCP @ 1/second, it'd be too verbose for viewer logs. -MG
-		LL_DEBUGS()  << "LLEventPollResponder::httpSuccess <" <<	mCount << "> " << events.size() << "events (id "
-					 <<	LLSDXMLStreamer(mAcknowledge) << ")" << LL_ENDL;
-		
-		LLSD::array_const_iterator i = events.beginArray();
-		LLSD::array_const_iterator end = events.endArray();
-		for	(; i !=	end; ++i)
-		{
-			if (i->has("message"))
-			{
-				handleMessage(*i);
-			}
-		}
-		
-		makeRequest();
-	}	
+    // We will wait RETRY_SECONDS + (errorCount * RETRY_SECONDS_INC) before retrying after an error.
+    // This means we attempt to recover relatively quickly but back off giving more time to recover
+    // until we finally give up after MAX_EVENT_POLL_HTTP_ERRORS attempts.
+    const F32 EVENT_POLL_ERROR_RETRY_SECONDS = 15.f; // ~ half of a normal timeout.
+    const F32 EVENT_POLL_ERROR_RETRY_SECONDS_INC = 5.f; // ~ half of a normal timeout.
+    const S32 MAX_EVENT_POLL_HTTP_ERRORS = 10; // ~5 minutes, by the above rules.
+
+#if 1
+
+    class LLEventPollImpl
+    {
+    public:
+        LLEventPollImpl(const LLHost &sender);
+
+        void start(const std::string &url);
+        void stop();
+    private:
+        void eventPollCoro(LLCoros::self& self, std::string url);
+
+        void                            handleMessage(const LLSD &content);
+
+        bool                            mDone;
+        LLCore::HttpRequest::ptr_t      mHttpRequest;
+        LLCore::HttpRequest::policy_t   mHttpPolicy;
+        std::string                     mSenderIp;
+        int                             mCounter;
+
+        static int                      sNextCounter;
+    };
+
+
+    int LLEventPollImpl::sNextCounter = 1;
+
+
+    LLEventPollImpl::LLEventPollImpl(const LLHost &sender) :
+        mDone(false),
+        mHttpRequest(),
+        mHttpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID),
+        mSenderIp(),
+        mCounter(sNextCounter++)
+
+    {
+        mHttpRequest = LLCore::HttpRequest::ptr_t(new LLCore::HttpRequest);
+        mSenderIp = sender.getIPandPort();
+    }
+
+    void LLEventPollImpl::handleMessage(const LLSD& content)
+    {
+        std::string	msg_name = content["message"];
+        LLSD message;
+        message["sender"] = mSenderIp;
+        message["body"] = content["body"];
+        LLMessageSystem::dispatch(msg_name, message);
+    }
+
+    void LLEventPollImpl::start(const std::string &url)
+    {
+        if (!url.empty())
+        {
+            std::string coroname =
+                LLCoros::instance().launch("LLAccountingCostManager::accountingCostCoro",
+                boost::bind(&LLEventPollImpl::eventPollCoro, this, _1, url));
+            LL_DEBUGS() << coroname << " with  url '" << url << LL_ENDL;
+        }
+    }
+
+    void LLEventPollImpl::stop()
+    {
+        mDone = true;
+    }
+
+    void LLEventPollImpl::eventPollCoro(LLCoros::self& self, std::string url)
+    {
+        LLCoreHttpUtil::HttpCoroutineAdapter httpAdapter("EventPoller", mHttpPolicy);
+        LLSD acknowledge;
+        int errorCount = 0;
+        int counter = mCounter; // saved on the stack for debugging.
+
+        LL_INFOS("LLEventPollImpl::eventPollCoro") << " <" << counter << "> entering coroutine." << LL_ENDL;
+
+        while (!mDone)
+        {
+            LLSD request;
+            request["ack"] = acknowledge;
+            request["done"] = mDone;
+
+//            LL_DEBUGS("LLEventPollImpl::eventPollCoro") << "<" << counter << "> request = "
+//                << LLSDXMLStreamer(request) << LL_ENDL;
+
+            LL_INFOS("LLEventPollImpl::eventPollCoro") << " <" << counter << "> posting and yielding." << LL_ENDL;
+            LLSD result = httpAdapter.postAndYield(self, mHttpRequest, url, request);
+
+//            LL_DEBUGS("LLEventPollImpl::eventPollCoro") << "<" << counter << "> result = "
+//                << LLSDXMLStreamer(result) << LL_ENDL;
+
+            if (mDone)
+                break;
+
+            LLSD httpResults;
+            httpResults = result["http_result"];
+
+
+            if (!httpResults["success"].asBoolean())
+            {
+                LL_WARNS("LLEventPollImpl::eventPollCoro") << "<" << counter << "> Error result from LLCoreHttpUtil::HttpCoroHandler. Code "
+                    << httpResults["status"] << ": '" << httpResults["message"] << "'" << LL_ENDL;
+
+                if (httpResults["status"].asInteger() == HTTP_BAD_GATEWAY)
+                {
+                    // A HTTP_BAD_GATEWAY (502) error is our standard timeout response
+                    // we get this when there are no events.
+                    errorCount = 0;
+                    continue;
+                }
+
+                LL_WARNS("LLEventPollImpl::eventPollCoro") << "<" << counter << "> " << LLSDXMLStreamer(result) << (mDone ? " -- done" : "") << LL_ENDL;
+
+                if (errorCount < MAX_EVENT_POLL_HTTP_ERRORS)
+                {
+                    ++errorCount;
+
+                    // The 'tick' will return TRUE causing the timer to delete this.
+                    int waitToRetry = EVENT_POLL_ERROR_RETRY_SECONDS
+                        + errorCount * EVENT_POLL_ERROR_RETRY_SECONDS_INC;
+
+                    LL_WARNS() << "Retrying in " << waitToRetry <<
+                        " seconds, error count is now " << errorCount << LL_ENDL;
+
+                    // *TODO: Wait for a timeout here
+                    //                     new LLEventPollEventTimer(
+                    //                         , this);
+                    continue;
+                }
+                else
+                {
+                    // At this point we have given up and the viewer will not receive HTTP messages from the simulator.
+                    // IMs, teleports, about land, selecting land, region crossing and more will all fail.
+                    // They are essentially disconnected from the region even though some things may still work.
+                    // Since things won't get better until they relog we force a disconnect now.
+
+                    mDone = true;
+
+                    // *NOTE:Mani - The following condition check to see if this failing event poll
+                    // is attached to the Agent's main region. If so we disconnect the viewer.
+                    // Else... its a child region and we just leave the dead event poll stopped and 
+                    // continue running.
+                    if (gAgent.getRegion() && gAgent.getRegion()->getHost().getIPandPort() == mSenderIp)
+                    {
+                        LL_WARNS("LLEventPollImpl::eventPollCoro") << "< " << counter << "> Forcing disconnect due to stalled main region event poll." << LL_ENDL;
+                        LLAppViewer::instance()->forceDisconnect(LLTrans::getString("AgentLostConnection"));
+                    }
+                    break;
+                }
+            }
+
+            LL_DEBUGS("LLEventPollImpl::eventPollCoro") << " <" << counter << ">"
+                << (mDone ? " -- done" : "") << LL_ENDL;
+
+            errorCount = 0;
+
+            if (!result.isMap() ||
+                !result.get("events") ||
+                !result.get("id"))
+            {
+                LL_WARNS("LLEventPollImpl::eventPollCoro") << " <" << counter << "> received event poll with no events or id key: " << LLSDXMLStreamer(result) << LL_ENDL;
+                continue;
+            }
+
+            acknowledge = result["id"];
+            LLSD events = result["events"];
+
+            if (acknowledge.isUndefined())
+            {
+                LL_WARNS("LLEventPollImpl::eventPollCoro") << " id undefined" << LL_ENDL;
+            }
+
+            // was LL_INFOS() but now that CoarseRegionUpdate is TCP @ 1/second, it'd be too verbose for viewer logs. -MG
+            LL_DEBUGS() << "LLEventPollResponder::httpSuccess <" << counter << "> " << events.size() << "events (id "
+                << LLSDXMLStreamer(acknowledge) << ")" << LL_ENDL;
+
+            LLSD::array_const_iterator i = events.beginArray();
+            LLSD::array_const_iterator end = events.endArray();
+            for (; i != end; ++i)
+            {
+                if (i->has("message"))
+                {
+                    handleMessage(*i);
+                }
+            }
+        }
+        LL_INFOS("LLEventPollImpl::eventPollCoro") << " <" << counter << "> Leaving coroutine." << LL_ENDL;
+
+    }
+
+#else
+    class LLEventPollResponder : public LLHTTPClient::Responder
+    {
+        LOG_CLASS(LLEventPollResponder);
+    public:
+
+        static LLHTTPClient::ResponderPtr start(const std::string& pollURL, const LLHost& sender);
+        void stop();
+
+        void makeRequest();
+
+        /* virtual */ void completedRaw(const LLChannelDescriptors& channels,
+            const LLIOPipe::buffer_ptr_t& buffer);
+
+    private:
+        LLEventPollResponder(const std::string&	pollURL, const LLHost& sender);
+        ~LLEventPollResponder();
+
+
+        void handleMessage(const LLSD& content);
+
+        /* virtual */ void httpFailure();
+        /* virtual */ void httpSuccess();
+
+    private:
+
+        bool	mDone;
+
+        std::string			mPollURL;
+        std::string			mSender;
+
+        LLSD	mAcknowledge;
+
+        // these are only here for debugging so	we can see which poller	is which
+        static int sCount;
+        int	mCount;
+        S32 mErrorCount;
+    };
+
+    class LLEventPollEventTimer : public LLEventTimer
+    {
+        typedef LLPointer<LLEventPollResponder> EventPollResponderPtr;
+
+    public:
+        LLEventPollEventTimer(F32 period, EventPollResponderPtr responder)
+            : LLEventTimer(period), mResponder(responder)
+        { }
+
+        virtual BOOL tick()
+        {
+            mResponder->makeRequest();
+            return TRUE;	// Causes this instance to be deleted.
+        }
+
+    private:
+
+        EventPollResponderPtr mResponder;
+    };
+
+    //static
+    LLHTTPClient::ResponderPtr LLEventPollResponder::start(
+        const std::string& pollURL, const LLHost& sender)
+    {
+        LLHTTPClient::ResponderPtr result = new LLEventPollResponder(pollURL, sender);
+        LL_INFOS()	<< "LLEventPollResponder::start <" << sCount << "> "
+            << pollURL << LL_ENDL;
+        return result;
+    }
+
+    void LLEventPollResponder::stop()
+    {
+        LL_INFOS()	<< "LLEventPollResponder::stop	<" << mCount <<	"> "
+            << mPollURL	<< LL_ENDL;
+        // there should	be a way to	stop a LLHTTPClient	request	in progress
+        mDone =	true;
+    }
+
+    int	LLEventPollResponder::sCount =	0;
+
+    LLEventPollResponder::LLEventPollResponder(const std::string& pollURL, const LLHost& sender)
+        : mDone(false),
+        mPollURL(pollURL),
+        mCount(++sCount),
+        mErrorCount(0)
+    {
+        //extract host and port of simulator to set as sender
+        LLViewerRegion *regionp = gAgent.getRegion();
+        if (!regionp)
+        {
+            LL_ERRS() << "LLEventPoll initialized before region is added." << LL_ENDL;
+        }
+        mSender = sender.getIPandPort();
+        LL_INFOS() << "LLEventPoll initialized with sender " << mSender << LL_ENDL;
+        makeRequest();
+    }
+
+    LLEventPollResponder::~LLEventPollResponder()
+    {
+        stop();
+        LL_DEBUGS() <<	"LLEventPollResponder::~Impl <" <<	mCount << "> "
+            <<	mPollURL <<	LL_ENDL;
+    }
+
+    // virtual 
+    void LLEventPollResponder::completedRaw(const LLChannelDescriptors& channels,
+        const LLIOPipe::buffer_ptr_t& buffer)
+    {
+        if (getStatus() == HTTP_BAD_GATEWAY)
+        {
+            // These errors are not parsable as LLSD, 
+            // which LLHTTPClient::Responder::completedRaw will try to do.
+            httpCompleted();
+        }
+        else
+        {
+            LLHTTPClient::Responder::completedRaw(channels,buffer);
+        }
+    }
+
+    void LLEventPollResponder::makeRequest()
+    {
+        LLSD request;
+        request["ack"] = mAcknowledge;
+        request["done"]	= mDone;
+
+        LL_DEBUGS() <<	"LLEventPollResponder::makeRequest	<" << mCount <<	"> ack = "
+            <<	LLSDXMLStreamer(mAcknowledge) << LL_ENDL;
+        LLHTTPClient::post(mPollURL, request, this);
+    }
+
+    void LLEventPollResponder::handleMessage(const	LLSD& content)
+    {
+        std::string	msg_name	= content["message"];
+        LLSD message;
+        message["sender"] = mSender;
+        message["body"] = content["body"];
+        LLMessageSystem::dispatch(msg_name, message);
+    }
+
+    //virtual
+    void LLEventPollResponder::httpFailure()
+    {
+        if (mDone) return;
+
+        // A HTTP_BAD_GATEWAY (502) error is our standard timeout response
+        // we get this when there are no events.
+        if ( getStatus() == HTTP_BAD_GATEWAY )
+        {
+            mErrorCount = 0;
+            makeRequest();
+        }
+        else if (mErrorCount < MAX_EVENT_POLL_HTTP_ERRORS)
+        {
+            ++mErrorCount;
+
+            // The 'tick' will return TRUE causing the timer to delete this.
+            new LLEventPollEventTimer(EVENT_POLL_ERROR_RETRY_SECONDS
+                + mErrorCount * EVENT_POLL_ERROR_RETRY_SECONDS_INC
+                , this);
+
+            LL_WARNS() << dumpResponse() << LL_ENDL;
+        }
+        else
+        {
+            LL_WARNS() << dumpResponse()
+                << " [count:" << mCount << "] "
+                << (mDone ? " -- done" : "") << LL_ENDL;
+            stop();
+
+            // At this point we have given up and the viewer will not receive HTTP messages from the simulator.
+            // IMs, teleports, about land, selecing land, region crossing and more will all fail.
+            // They are essentially disconnected from the region even though some things may still work.
+            // Since things won't get better until they relog we force a disconnect now.
+
+            // *NOTE:Mani - The following condition check to see if this failing event poll
+            // is attached to the Agent's main region. If so we disconnect the viewer.
+            // Else... its a child region and we just leave the dead event poll stopped and 
+            // continue running.
+            if(gAgent.getRegion() && gAgent.getRegion()->getHost().getIPandPort() == mSender)
+            {
+                LL_WARNS() << "Forcing disconnect due to stalled main region event poll."  << LL_ENDL;
+                LLAppViewer::instance()->forceDisconnect(LLTrans::getString("AgentLostConnection"));
+            }
+        }
+    }
+
+    //virtual
+    void LLEventPollResponder::httpSuccess()
+    {
+        LL_DEBUGS() <<	"LLEventPollResponder::result <" << mCount	<< ">"
+            <<	(mDone ? " -- done"	: "") << LL_ENDL;
+
+        if (mDone) return;
+
+        mErrorCount = 0;
+
+        const LLSD& content = getContent();
+        if (!content.isMap() ||
+            !content.get("events") ||
+            !content.get("id"))
+        {
+            LL_WARNS() << "received event poll with no events or id key: " << dumpResponse() << LL_ENDL;
+            makeRequest();
+            return;
+        }
+
+        mAcknowledge = content["id"];
+        LLSD events	= content["events"];
+
+        if(mAcknowledge.isUndefined())
+        {
+            LL_WARNS() << "LLEventPollResponder: id undefined" << LL_ENDL;
+        }
+
+        // was LL_INFOS() but now that CoarseRegionUpdate is TCP @ 1/second, it'd be too verbose for viewer logs. -MG
+        LL_DEBUGS()  << "LLEventPollResponder::httpSuccess <" <<	mCount << "> " << events.size() << "events (id "
+            <<	LLSDXMLStreamer(mAcknowledge) << ")" << LL_ENDL;
+
+        LLSD::array_const_iterator i = events.beginArray();
+        LLSD::array_const_iterator end = events.endArray();
+        for	(; i !=	end; ++i)
+        {
+            if (i->has("message"))
+            {
+                handleMessage(*i);
+            }
+        }
+
+        makeRequest();
+    }	
 }
 
 LLEventPoll::LLEventPoll(const std::string&	poll_url, const LLHost& sender)
-	: mImpl(LLEventPollResponder::start(poll_url, sender))
-	{ }
+    : mImpl(LLEventPollResponder::start(poll_url, sender))
+{ }
 
 LLEventPoll::~LLEventPoll()
 {
-	LLHTTPClient::Responder* responderp = mImpl.get();
-	LLEventPollResponder* event_poll_responder = dynamic_cast<LLEventPollResponder*>(responderp);
-	if (event_poll_responder) event_poll_responder->stop();
+    LLHTTPClient::Responder* responderp = mImpl.get();
+    LLEventPollResponder* event_poll_responder = dynamic_cast<LLEventPollResponder*>(responderp);
+    if (event_poll_responder) event_poll_responder->stop();
+}
+#endif
+}
+
+LLEventPoll::LLEventPoll(const std::string&	poll_url, const LLHost& sender):
+    mImpl()
+{ 
+    mImpl = boost::unique_ptr<LLEventPollImpl>(new LLEventPollImpl(sender));
+    mImpl->start(poll_url);
+}
+
+LLEventPoll::~LLEventPoll()
+{
+    mImpl->stop();
+
 }
diff --git a/indra/newview/lleventpoll.h b/indra/newview/lleventpoll.h
index e8d98062aa..4b9944724d 100755
--- a/indra/newview/lleventpoll.h
+++ b/indra/newview/lleventpoll.h
@@ -28,9 +28,20 @@
 #define LL_LLEVENTPOLL_H
 
 #include "llhttpclient.h"
+#include "boost/move/unique_ptr.hpp"
+
+namespace boost
+{
+    using ::boost::movelib::unique_ptr; // move unique_ptr into the boost namespace.
+}
 
 class LLHost;
 
+namespace
+{
+    class LLEventPollImpl;
+}
+
 
 class LLEventPoll
 	///< implements the viewer side of server-to-viewer pushed events.
@@ -40,11 +51,15 @@ public:
 		///< Start polling the URL.
 
 	virtual ~LLEventPoll();
-		///< will stop polling, cancelling any poll in progress.
+		///< will stop polling, canceling any poll in progress.
 
 
 private:
+#if 1
+    boost::unique_ptr<LLEventPollImpl>    mImpl;
+#else
 	LLHTTPClient::ResponderPtr mImpl;
+#endif
 };
 
 
-- 
cgit v1.3


From d0c85b6dd964164b6d92103ad65b5cd859197de2 Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Fri, 10 Apr 2015 17:23:58 -0700
Subject: Adding support for DELETE, PATCH and COPY

---
 indra/llcorehttp/_httpoprequest.cpp | 68 +++++++++++++++++++++++----
 indra/llcorehttp/_httpoprequest.h   | 26 +++++++++-
 indra/llcorehttp/httprequest.cpp    | 94 +++++++++++++++++++++++++++++++++++++
 indra/llcorehttp/httprequest.h      | 63 ++++++++++++++++++++++++-
 indra/llmessage/llcorehttputil.cpp  | 40 ++++++++++++++++
 indra/llmessage/llcorehttputil.h    | 35 ++++++++++++++
 6 files changed, 315 insertions(+), 11 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/_httpoprequest.cpp b/indra/llcorehttp/_httpoprequest.cpp
index 7c2309b31d..b1b05dc285 100755
--- a/indra/llcorehttp/_httpoprequest.cpp
+++ b/indra/llcorehttp/_httpoprequest.cpp
@@ -357,6 +357,46 @@ HttpStatus HttpOpRequest::setupPut(HttpRequest::policy_t policy_id,
 }
 
 
+HttpStatus HttpOpRequest::setupDelete(HttpRequest::policy_t policy_id,
+    HttpRequest::priority_t priority,
+    const std::string & url,
+    HttpOptions * options,
+    HttpHeaders * headers)
+{
+    setupCommon(policy_id, priority, url, NULL, options, headers);
+    mReqMethod = HOR_DELETE;
+
+    return HttpStatus();
+}
+
+
+HttpStatus HttpOpRequest::setupPatch(HttpRequest::policy_t policy_id,
+    HttpRequest::priority_t priority,
+    const std::string & url,
+    BufferArray * body,
+    HttpOptions * options,
+    HttpHeaders * headers)
+{
+    setupCommon(policy_id, priority, url, body, options, headers);
+    mReqMethod = HOR_PATCH;
+
+    return HttpStatus();
+}
+
+
+HttpStatus HttpOpRequest::setupCopy(HttpRequest::policy_t policy_id,
+    HttpRequest::priority_t priority,
+    const std::string & url,
+    HttpOptions * options,
+    HttpHeaders * headers)
+{
+    setupCommon(policy_id, priority, url, NULL, options, headers);
+    mReqMethod = HOR_COPY;
+
+    return HttpStatus();
+}
+
+
 void HttpOpRequest::setupCommon(HttpRequest::policy_t policy_id,
 								HttpRequest::priority_t priority,
 								const std::string & url,
@@ -549,8 +589,6 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 	case HOR_GET:
 		code = curl_easy_setopt(mCurlHandle, CURLOPT_HTTPGET, 1);
 		check_curl_easy_code(code, CURLOPT_HTTPGET);
-		mCurlHeaders = curl_slist_append(mCurlHeaders, "Connection: keep-alive");
-		mCurlHeaders = curl_slist_append(mCurlHeaders, "Keep-alive: 300");
 		break;
 		
 	case HOR_POST:
@@ -569,12 +607,14 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 			code = curl_easy_setopt(mCurlHandle, CURLOPT_POSTFIELDSIZE, data_size);
 			check_curl_easy_code(code, CURLOPT_POSTFIELDSIZE);
 			mCurlHeaders = curl_slist_append(mCurlHeaders, "Expect:");
-			mCurlHeaders = curl_slist_append(mCurlHeaders, "Connection: keep-alive");
-			mCurlHeaders = curl_slist_append(mCurlHeaders, "Keep-alive: 300");
 		}
 		break;
 		
-	case HOR_PUT:
+    case HOR_PATCH:
+        code = curl_easy_setopt(mCurlHandle, CURLOPT_CUSTOMREQUEST, "PATCH");
+        check_curl_easy_code(code, CURLOPT_CUSTOMREQUEST);
+        // fall through.  The rest is the same as PUT
+    case HOR_PUT:
 		{
 			code = curl_easy_setopt(mCurlHandle, CURLOPT_UPLOAD, 1);
 			check_curl_easy_code(code, CURLOPT_UPLOAD);
@@ -588,12 +628,19 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 			code = curl_easy_setopt(mCurlHandle, CURLOPT_POSTFIELDS, (void *) NULL);
 			check_curl_easy_code(code, CURLOPT_POSTFIELDS);
 			mCurlHeaders = curl_slist_append(mCurlHeaders, "Expect:");
-			// *TODO: Should this be 'Keep-Alive' ?
-			mCurlHeaders = curl_slist_append(mCurlHeaders, "Connection: keep-alive");
-			mCurlHeaders = curl_slist_append(mCurlHeaders, "Keep-alive: 300");
 		}
 		break;
 		
+    case HOR_DELETE:
+        code = curl_easy_setopt(mCurlHandle, CURLOPT_CUSTOMREQUEST, "DELETE");
+        check_curl_easy_code(code, CURLOPT_CUSTOMREQUEST);
+        break;
+
+    case HOR_COPY:
+        code = curl_easy_setopt(mCurlHandle, CURLOPT_CUSTOMREQUEST, "COPY");
+        check_curl_easy_code(code, CURLOPT_CUSTOMREQUEST);
+        break;
+
 	default:
 		LL_ERRS(LOG_CORE) << "Invalid HTTP method in request:  "
 						  << int(mReqMethod)  << ".  Can't recover."
@@ -601,6 +648,11 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 		break;
 	}
 
+
+    // *TODO: Should this be 'Keep-Alive' ?
+    mCurlHeaders = curl_slist_append(mCurlHeaders, "Connection: keep-alive");
+    mCurlHeaders = curl_slist_append(mCurlHeaders, "Keep-alive: 300");
+
 	// Tracing
 	if (mTracing >= HTTP_TRACE_CURL_HEADERS)
 	{
diff --git a/indra/llcorehttp/_httpoprequest.h b/indra/llcorehttp/_httpoprequest.h
index e71d1d1edf..ca40898a81 100755
--- a/indra/llcorehttp/_httpoprequest.h
+++ b/indra/llcorehttp/_httpoprequest.h
@@ -80,7 +80,10 @@ public:
 	{
 		HOR_GET,
 		HOR_POST,
-		HOR_PUT
+		HOR_PUT,
+        HOR_DELETE,
+        HOR_PATCH,
+        HOR_COPY
 	};
 	
 	virtual void stageFromRequest(HttpService *);
@@ -126,7 +129,26 @@ public:
 						HttpOptions * options,
 						HttpHeaders * headers);
 
-	// Internal method used to setup the libcurl options for a request.
+    HttpStatus setupDelete(HttpRequest::policy_t policy_id,
+                        HttpRequest::priority_t priority,
+                        const std::string & url,
+                        HttpOptions * options,
+                        HttpHeaders * headers);
+
+    HttpStatus setupPatch(HttpRequest::policy_t policy_id,
+                        HttpRequest::priority_t priority,
+                        const std::string & url,
+                        BufferArray * body,
+                        HttpOptions * options,
+                        HttpHeaders * headers);
+
+    HttpStatus setupCopy(HttpRequest::policy_t policy_id,
+                        HttpRequest::priority_t priority,
+                        const std::string & url,
+                        HttpOptions * options,
+                        HttpHeaders * headers);
+
+    // Internal method used to setup the libcurl options for a request.
 	// Does all the libcurl handle setup in one place.
 	//
 	// Threading:  called by worker thread
diff --git a/indra/llcorehttp/httprequest.cpp b/indra/llcorehttp/httprequest.cpp
index df8502b947..d4c60a6f14 100755
--- a/indra/llcorehttp/httprequest.cpp
+++ b/indra/llcorehttp/httprequest.cpp
@@ -325,6 +325,100 @@ HttpHandle HttpRequest::requestPut(policy_t policy_id,
 	return handle;
 }
 
+HttpHandle HttpRequest::requestDelete(policy_t policy_id,
+    priority_t priority,
+    const std::string & url,
+    HttpOptions * options,
+    HttpHeaders * headers,
+    HttpHandler * user_handler)
+{
+    HttpStatus status;
+    HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
+
+    HttpOpRequest * op = new HttpOpRequest();
+    if (!(status = op->setupDelete(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::requestPatch(policy_t policy_id,
+    priority_t priority,
+    const std::string & url,
+    BufferArray * body,
+    HttpOptions * options,
+    HttpHeaders * headers,
+    HttpHandler * user_handler)
+{
+    HttpStatus status;
+    HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
+
+    HttpOpRequest * op = new HttpOpRequest();
+    if (!(status = op->setupPatch(policy_id, priority, url, body, 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::requestCopy(policy_t policy_id,
+    priority_t priority,
+    const std::string & url,
+    HttpOptions * options,
+    HttpHeaders * headers,
+    HttpHandler * user_handler)
+{
+    HttpStatus status;
+    HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
+
+    HttpOpRequest * op = new HttpOpRequest();
+    if (!(status = op->setupCopy(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 6688f06eb5..e87a8b691a 100755
--- a/indra/llcorehttp/httprequest.h
+++ b/indra/llcorehttp/httprequest.h
@@ -478,7 +478,68 @@ public:
 						  HttpHandler * handler);
 
 
-	/// Queue a NoOp request.
+    /// Queue a full HTTP PUT.  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 requestDelete(policy_t policy_id,
+            priority_t priority,
+            const std::string & url,
+            HttpOptions * options,
+            HttpHeaders * headers,
+            HttpHandler * user_handler);
+
+    /// Queue a full HTTP PUT.  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	body			Byte stream to be sent as the body.  No
+    ///							further encoding or escaping will be done
+    ///							to the content.
+    /// @param	options			@see requestGet()K(optional)
+    /// @param	headers			"
+    /// @param	handler			"
+    /// @return					"
+    ///
+    HttpHandle requestPatch(policy_t policy_id,
+            priority_t priority,
+            const std::string & url,
+            BufferArray * body,
+            HttpOptions * options,
+            HttpHeaders * headers,
+            HttpHandler * user_handler);
+
+    /// Queue a full HTTP PUT.  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 requestCopy(policy_t policy_id,
+            priority_t priority,
+            const std::string & url,
+            HttpOptions * options,
+            HttpHeaders * 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
 	/// queue.
diff --git a/indra/llmessage/llcorehttputil.cpp b/indra/llmessage/llcorehttputil.cpp
index a32c4cad22..2d6cca214c 100644
--- a/indra/llmessage/llcorehttputil.cpp
+++ b/indra/llmessage/llcorehttputil.cpp
@@ -142,6 +142,46 @@ HttpHandle requestPutWithLLSD(HttpRequest::ptr_t & request,
         url, body, options.get(), headers.get(), handler);
 }
 
+HttpHandle requestPatchWithLLSD(HttpRequest * request,
+    HttpRequest::policy_t policy_id,
+    HttpRequest::priority_t priority,
+    const std::string & url,
+    const LLSD & body,
+    HttpOptions * options,
+    HttpHeaders * headers,
+    HttpHandler * handler)
+{
+    HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
+
+    BufferArray * ba = new BufferArray();
+    BufferArrayStream bas(ba);
+    LLSDSerialize::toXML(body, bas);
+
+    handle = request->requestPatch(policy_id,
+        priority,
+        url,
+        ba,
+        options,
+        headers,
+        handler);
+    ba->release();
+    return handle;
+}
+
+HttpHandle requestPatchWithLLSD(HttpRequest::ptr_t & request,
+    HttpRequest::policy_t policy_id,
+    HttpRequest::priority_t priority,
+    const std::string & url,
+    const LLSD & body,
+    HttpOptions::ptr_t & options,
+    HttpHeaders::ptr_t & headers,
+    HttpHandler * handler)
+{
+    return requestPatchWithLLSD(request.get(), policy_id, priority,
+        url, body, options.get(), headers.get(), handler);
+}
+
+
 std::string responseToString(LLCore::HttpResponse * response)
 {
     static const std::string empty("[Empty]");
diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 471710f61b..6fcf03b95c 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -155,6 +155,41 @@ LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
 	LLCore::HttpHeaders::ptr_t & headers,
 	LLCore::HttpHandler * handler);
 
+/// Issue a standard HttpRequest::requestPatch() call but using
+/// and LLSD object as the request body.  Conventions are the
+/// same as with that method.  Caller is expected to provide
+/// an HttpHeaders object with a correct 'Content-Type:' header.
+/// One will not be provided by this call.
+///
+/// @return				If request is successfully issued, the
+///						HttpHandle representing the request.
+///						On error, LLCORE_HTTP_HANDLE_INVALID
+///						is returned and caller can fetch detailed
+///						status with the getStatus() method on the
+///						request object.  In case of error, no
+///						request is queued and caller may need to
+///						perform additional cleanup such as freeing
+///						a now-useless HttpHandler object.
+///
+LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest * request,
+    LLCore::HttpRequest::policy_t policy_id,
+    LLCore::HttpRequest::priority_t priority,
+    const std::string & url,
+    const LLSD & body,
+    LLCore::HttpOptions * options,
+    LLCore::HttpHeaders * headers,
+    LLCore::HttpHandler * handler);
+
+LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & request,
+    LLCore::HttpRequest::policy_t policy_id,
+    LLCore::HttpRequest::priority_t priority,
+    const std::string & url,
+    const LLSD & body,
+    LLCore::HttpOptions::ptr_t & options,
+    LLCore::HttpHeaders::ptr_t & headers,
+    LLCore::HttpHandler * handler);
+
+
 /// The HttpCoroHandler is a specialization of the LLCore::HttpHandler for 
 /// interacting with coroutines. When the request is completed the response 
 /// will be posted onto the supplied Event Pump.
-- 
cgit v1.3


From da32de179d50d85cd815c545282d274d18c9dc3e Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Tue, 28 Apr 2015 09:39:47 -0700
Subject: Converting llmediaclient to new order. Temp disable llmediaclient's
 unit tests for link issues.

---
 indra/llcorehttp/httphandler.h      |   5 +-
 indra/llmessage/llhttpsdhandler.cpp |  16 +-
 indra/llmessage/llhttpsdhandler.h   |  15 +-
 indra/newview/CMakeLists.txt        |   4 +-
 indra/newview/llmediadataclient.cpp | 378 ++++++++++++++++++------------------
 indra/newview/llmediadataclient.h   |  80 ++++----
 6 files changed, 262 insertions(+), 236 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/httphandler.h b/indra/llcorehttp/httphandler.h
index 740e986dec..7bc9096703 100755
--- a/indra/llcorehttp/httphandler.h
+++ b/indra/llcorehttp/httphandler.h
@@ -53,8 +53,9 @@ class HttpResponse;
 /// that is rarely a good idea.  Queued requests and replies keep
 /// a naked pointer to the handler and this can result in a
 /// dangling pointer if lifetimes aren't managed correctly.
-
-class HttpHandler
+///
+/// *TODO: public std::enable_shared_from_this<HttpHandler>
+class HttpHandler 
 {
 public:
 	virtual ~HttpHandler()
diff --git a/indra/llmessage/llhttpsdhandler.cpp b/indra/llmessage/llhttpsdhandler.cpp
index 159d03b176..d99bdd3f66 100644
--- a/indra/llmessage/llhttpsdhandler.cpp
+++ b/indra/llmessage/llhttpsdhandler.cpp
@@ -36,7 +36,8 @@
 #include "llcorehttputil.h"
 
 //========================================================================
-LLHttpSDHandler::LLHttpSDHandler()
+LLHttpSDHandler::LLHttpSDHandler(bool selfDelete):
+    mSelfDelete(selfDelete)
 {
 }
 
@@ -77,26 +78,27 @@ void LLHttpSDHandler::onCompleted(LLCore::HttpHandle handle, LLCore::HttpRespons
 	// The handler must destroy itself when it is done. 
 	// *TODO: I'm not fond of this pattern. A class shooting itself in the head 
 	// outside of a smart pointer always makes me nervous.
-	delete this;
+    if (mSelfDelete)
+    	delete this;
 }
 
 //========================================================================
-LLHttpSDGenericHandler::LLHttpSDGenericHandler(const std::string &caps) :
-	LLHttpSDHandler(),
-	mCaps(caps)
+LLHttpSDGenericHandler::LLHttpSDGenericHandler(const std::string &name, bool selfDelete):
+	LLHttpSDHandler(selfDelete),
+	mName(name)
 {
 }
 
 void LLHttpSDGenericHandler::onSuccess(LLCore::HttpResponse * response, const LLSD &content)
 {
-	LL_DEBUGS() << mCaps << " Success." << LL_ENDL;
+	LL_DEBUGS() << mName << " Success." << LL_ENDL;
 }
 
 void LLHttpSDGenericHandler::onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status)
 {
 	LL_WARNS()
 		<< "\n--------------------------------------------------------------------------\n"
-		<< mCaps << " Error[" << status.toULong() << "] cannot access cap with url '" 
+		<< mName << " Error[" << status.toULong() << "] cannot access cap with url '" 
 		<< response->getRequestURL() << "' because " << status.toString()
 		<< "\n--------------------------------------------------------------------------"
 		<< LL_ENDL;
diff --git a/indra/llmessage/llhttpsdhandler.h b/indra/llmessage/llhttpsdhandler.h
index 7c28dbcab6..814d1c22b5 100644
--- a/indra/llmessage/llhttpsdhandler.h
+++ b/indra/llmessage/llhttpsdhandler.h
@@ -36,32 +36,37 @@
 /// 
 // *TODO: This class self deletes at the end of onCompleted method.  This is 
 // less than ideal and should be revisited.
-class LLHttpSDHandler : public LLCore::HttpHandler
+class LLHttpSDHandler : public LLCore::HttpHandler //,
+//    public std::enable_shared_from_this<LLHttpSDHandler>
 {
 public:
-	LLHttpSDHandler();
 
 	virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);
 	
 protected:
+    LLHttpSDHandler(bool selfDelete = true);
+
 	virtual void onSuccess(LLCore::HttpResponse * response, const LLSD &content) = 0;
 	virtual void onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status) = 0;
 
+private:
+    bool mSelfDelete;
+
 };
 
 /// A trivial implementation of LLHttpSDHandler. This success and failure 
-/// methods log the action taken, the URI accessed and the status code retuned 
+/// methods log the action taken, the URI accessed and the status code returned 
 /// in the response.
 class LLHttpSDGenericHandler : public LLHttpSDHandler
 {
 public: 
-	LLHttpSDGenericHandler(const std::string &action);
+	LLHttpSDGenericHandler(const std::string &name, bool selfDelete = true);
 
 protected:
 	virtual void onSuccess(LLCore::HttpResponse * response, const LLSD &content);
 	virtual void onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status);
 
 private:
-	std::string mCaps;
+	std::string mName;
 };
 #endif
\ No newline at end of file
diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt
index 3858383e39..13436ecb16 100755
--- a/indra/newview/CMakeLists.txt
+++ b/indra/newview/CMakeLists.txt
@@ -2218,7 +2218,7 @@ if (LL_TESTS)
   SET(viewer_TEST_SOURCE_FILES
     llagentaccess.cpp
     lldateutil.cpp
-    llmediadataclient.cpp
+#    llmediadataclient.cpp
     lllogininstance.cpp
     llremoteparcelrequest.cpp
     lltranslate.cpp
@@ -2251,7 +2251,7 @@ if (LL_TESTS)
   set_source_files_properties(
     llmediadataclient.cpp
     PROPERTIES
-    LL_TEST_ADDITIONAL_LIBRARIES "${CURL_LIBRARIES}"
+    LL_TEST_ADDITIONAL_LIBRARIES "${test_libs}"
   )
 
   set_source_files_properties(
diff --git a/indra/newview/llmediadataclient.cpp b/indra/newview/llmediadataclient.cpp
index 2fb9e60b29..2a53e3fe78 100755
--- a/indra/newview/llmediadataclient.cpp
+++ b/indra/newview/llmediadataclient.cpp
@@ -40,6 +40,7 @@
 #include "llmediaentry.h"
 #include "lltextureentry.h"
 #include "llviewerregion.h"
+#include "llcorehttputil.h"
 
 //
 // When making a request
@@ -145,18 +146,20 @@ void remove_matching_requests(T &c, const LLUUID &id, LLMediaDataClient::Request
 //
 //////////////////////////////////////////////////////////////////////////////////////
 
-LLMediaDataClient::LLMediaDataClient(F32 queue_timer_delay,
-									 F32 retry_timer_delay,
-									 U32 max_retries,
-									 U32 max_sorted_queue_size,
-									 U32 max_round_robin_queue_size)
-	: mQueueTimerDelay(queue_timer_delay),
-	  mRetryTimerDelay(retry_timer_delay),
-	  mMaxNumRetries(max_retries),
-	  mMaxSortedQueueSize(max_sorted_queue_size),
-	  mMaxRoundRobinQueueSize(max_round_robin_queue_size),
-	  mQueueTimerIsRunning(false)
+LLMediaDataClient::LLMediaDataClient(F32 queue_timer_delay, F32 retry_timer_delay,  
+        U32 max_retries, U32 max_sorted_queue_size, U32 max_round_robin_queue_size):
+    mQueueTimerDelay(queue_timer_delay),
+    mRetryTimerDelay(retry_timer_delay),
+    mMaxNumRetries(max_retries),
+    mMaxSortedQueueSize(max_sorted_queue_size),
+    mMaxRoundRobinQueueSize(max_round_robin_queue_size),
+    mQueueTimerIsRunning(false),
+    mHttpRequest(new LLCore::HttpRequest()),
+    mHttpHeaders(new LLCore::HttpHeaders(), false),
+    mHttpOpts(new LLCore::HttpOptions(), false),
+    mHttpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID)
 {
+    // *TODO: Look up real Policy ID
 }
 
 LLMediaDataClient::~LLMediaDataClient()
@@ -207,18 +210,19 @@ void LLMediaDataClient::stopQueueTimer()
 
 bool LLMediaDataClient::processQueueTimer()
 {
-	if(isEmpty())
+    if (isDoneProcessing())
 		return true;
 
 	LL_DEBUGS("LLMediaDataClient") << "QueueTimer::tick() started, queue size is:	  " << mQueue.size() << LL_ENDL;
 	LL_DEBUGS("LLMediaDataClientQueue") << "QueueTimer::tick() started, SORTED queue is:	  " << mQueue << LL_ENDL;
 			
 	serviceQueue();
-	
+    serviceHttp();
+
 	LL_DEBUGS("LLMediaDataClient") << "QueueTimer::tick() finished, queue size is:	  " << mQueue.size() << LL_ENDL;
 	LL_DEBUGS("LLMediaDataClientQueue") << "QueueTimer::tick() finished, SORTED queue is:	  " << mQueue << LL_ENDL;
 	
-	return isEmpty();
+    return isDoneProcessing();
 }
 
 LLMediaDataClient::request_ptr_t LLMediaDataClient::dequeue()
@@ -283,6 +287,12 @@ void LLMediaDataClient::stopTrackingRequest(request_ptr_t request)
 	}
 }
 
+bool LLMediaDataClient::isDoneProcessing() const
+{
+    return (isEmpty() && mUnQueuedRequests.empty());
+}
+
+
 void LLMediaDataClient::serviceQueue()
 {	
 	// Peel one off of the items from the queue and execute it
@@ -317,7 +327,18 @@ void LLMediaDataClient::serviceQueue()
 		trackRequest(request);
 		
 		// and make the post
-		LLHTTPClient::post(url, sd_payload, request->createResponder());
+        LLHttpSDHandler *handler = request->createHandler();
+        LLCore::HttpHandle handle = LLCoreHttpUtil::requestPostWithLLSD(mHttpRequest, mHttpPolicy, 0,
+            url, sd_payload, mHttpOpts, mHttpHeaders, handler);
+
+        if (handle == LLCORE_HTTP_HANDLE_INVALID)
+        {
+            // *TODO: Change this metaphore to use boost::shared_ptr<> for handlers.  Requires change in LLCore::HTTP
+            delete handler;
+            LLCore::HttpStatus status = mHttpRequest->getStatus();
+            LL_WARNS("LLMediaDataClient") << "'" << url << "' request POST failed. Reason "
+                << status.toTerseString() << " \"" << status.toString() << "\"" << LL_ENDL;
+        }
 	}
 	else 
 	{
@@ -332,13 +353,17 @@ void LLMediaDataClient::serviceQueue()
 		}
 		else
 		{
-			// This request has exceeded its maxumim retry count.  It will be dropped.
+			// This request has exceeded its maximum retry count.  It will be dropped.
 			LL_WARNS("LLMediaDataClient") << "Could not send request " << *request << " for " << mMaxNumRetries << " tries, dropping request." << LL_ENDL; 
 		}
 
 	}
 }
 
+void LLMediaDataClient::serviceHttp()
+{
+    mHttpRequest->update(0);
+}
 
 // dump the queue
 std::ostream& operator<<(std::ostream &s, const LLMediaDataClient::request_queue_t &q)
@@ -551,79 +576,67 @@ std::ostream& operator<<(std::ostream &s, const LLMediaDataClient::Request &r)
 	<< " #retries=" << r.getRetryCount();
 	return s;
 }
-			
-//////////////////////////////////////////////////////////////////////////////////////
-//
-// LLMediaDataClient::Responder
-//
-//////////////////////////////////////////////////////////////////////////////////////
 
-LLMediaDataClient::Responder::Responder(const request_ptr_t &request)
-: mRequest(request)
+//========================================================================
+
+LLMediaDataClient::Handler::Handler(const request_ptr_t &request):
+    mRequest(request)
 {
 }
 
-/*virtual*/
-void LLMediaDataClient::Responder::httpFailure()
+
+void LLMediaDataClient::Handler::onSuccess(LLCore::HttpResponse * response, const LLSD &content)
 {
-	mRequest->stopTracking();
+    mRequest->stopTracking();
 
-	if(mRequest->isDead())
-	{
-		LL_WARNS("LLMediaDataClient") << "dead request " << *mRequest << LL_ENDL;
-		return;
-	}
-	
-	if (getStatus() == HTTP_SERVICE_UNAVAILABLE)
-	{
-		F32 retry_timeout;
-#if 0
-		// *TODO: Honor server Retry-After header.
-		if (!hasResponseHeader(HTTP_IN_HEADER_RETRY_AFTER)
-			|| !getSecondsUntilRetryAfter(getResponseHeader(HTTP_IN_HEADER_RETRY_AFTER), retry_timeout))
-#endif
-		{
-			retry_timeout = mRequest->getRetryTimerDelay();
-		}
-		
-		mRequest->incRetryCount();
-		
-		if (mRequest->getRetryCount() < mRequest->getMaxNumRetries()) 
-		{
-			LL_INFOS("LLMediaDataClient") << *mRequest << " got SERVICE_UNAVAILABLE...retrying in " << retry_timeout << " seconds" << LL_ENDL;
-			
-			// Start timer (instances are automagically tracked by
-			// InstanceTracker<> and LLEventTimer)
-			new RetryTimer(F32(retry_timeout/*secs*/), mRequest);
-		}
-		else 
-		{
-			LL_INFOS("LLMediaDataClient") << *mRequest << " got SERVICE_UNAVAILABLE...retry count " 
-				<< mRequest->getRetryCount() << " exceeds " << mRequest->getMaxNumRetries() << ", not retrying" << LL_ENDL;
-		}
-	}
-	// *TODO: Redirect on 3xx status codes.
-	else 
-	{
-		LL_WARNS("LLMediaDataClient") << *mRequest << " http failure "
-				<< dumpResponse() << LL_ENDL;
-	}
+    if (mRequest->isDead())
+    {
+        LL_WARNS("LLMediaDataClient") << "dead request " << *mRequest << LL_ENDL;
+        return;
+    }
+
+    LL_DEBUGS("LLMediaDataClientResponse") << *mRequest << LL_ENDL;
 }
 
-/*virtual*/
-void LLMediaDataClient::Responder::httpSuccess()
+void LLMediaDataClient::Handler::onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status)
 {
-	mRequest->stopTracking();
+    mRequest->stopTracking();
 
-	if(mRequest->isDead())
-	{
-		LL_WARNS("LLMediaDataClient") << "dead request " << *mRequest << LL_ENDL;
-		return;
-	}
+    if (status == LLCore::HttpStatus(HTTP_SERVICE_UNAVAILABLE))
+    {
+        F32 retry_timeout;
+#if 0
+        // *TODO: Honor server Retry-After header.
+        if (!hasResponseHeader(HTTP_IN_HEADER_RETRY_AFTER)
+            || !getSecondsUntilRetryAfter(getResponseHeader(HTTP_IN_HEADER_RETRY_AFTER), retry_timeout))
+#endif
+        {
+            retry_timeout = mRequest->getRetryTimerDelay();
+        }
+
+        mRequest->incRetryCount();
 
-	LL_DEBUGS("LLMediaDataClientResponse") << *mRequest << " " << dumpResponse() << LL_ENDL;
+        if (mRequest->getRetryCount() < mRequest->getMaxNumRetries()) 
+        {
+            LL_INFOS("LLMediaDataClient") << *mRequest << " got SERVICE_UNAVAILABLE...retrying in " << retry_timeout << " seconds" << LL_ENDL;
+
+            // Start timer (instances are automagically tracked by
+            // InstanceTracker<> and LLEventTimer)
+            new RetryTimer(F32(retry_timeout/*secs*/), mRequest);
+        }
+        else 
+        {
+            LL_INFOS("LLMediaDataClient") << *mRequest << " got SERVICE_UNAVAILABLE...retry count " 
+                << mRequest->getRetryCount() << " exceeds " << mRequest->getMaxNumRetries() << ", not retrying" << LL_ENDL;
+        }
+    }
+    else
+    {
+        LL_WARNS("LLMediaDataClient") << *mRequest << " HTTP failure " << LL_ENDL;
+    }
 }
 
+
 //////////////////////////////////////////////////////////////////////////////////////
 //
 // LLObjectMediaDataClient
@@ -801,7 +814,7 @@ void LLObjectMediaDataClient::removeFromQueue(const LLMediaDataClientObject::ptr
 
 bool LLObjectMediaDataClient::processQueueTimer()
 {
-	if(isEmpty())
+    if (isDoneProcessing())
 		return true;
 		
 	LL_DEBUGS("LLMediaDataClient") << "started, SORTED queue size is:	  " << mQueue.size() 
@@ -816,6 +829,7 @@ bool LLObjectMediaDataClient::processQueueTimer()
 	LL_DEBUGS("LLMediaDataClientQueue") << "after sort, SORTED queue is:	  " << mQueue << LL_ENDL;
 	
 	serviceQueue();
+    serviceHttp();
 
 	swapCurrentQueue();
 	
@@ -824,7 +838,7 @@ bool LLObjectMediaDataClient::processQueueTimer()
 	LL_DEBUGS("LLMediaDataClientQueue") << "    SORTED queue is:	  " << mQueue << LL_ENDL;
 	LL_DEBUGS("LLMediaDataClientQueue") << "    RR queue is:	  " << mRoundRobinQueue << LL_ENDL;
 	
-	return isEmpty();
+    return isDoneProcessing();
 }
 
 LLObjectMediaDataClient::RequestGet::RequestGet(LLMediaDataClientObject *obj, LLMediaDataClient *mdc):
@@ -841,9 +855,9 @@ LLSD LLObjectMediaDataClient::RequestGet::getPayload() const
 	return result;
 }
 
-LLMediaDataClient::Responder *LLObjectMediaDataClient::RequestGet::createResponder()
+LLHttpSDHandler *LLObjectMediaDataClient::RequestGet::createHandler()
 {
-	return new LLObjectMediaDataClient::Responder(this);
+	return new LLObjectMediaDataClient::Handler(this);
 }
 
 
@@ -877,60 +891,58 @@ LLSD LLObjectMediaDataClient::RequestUpdate::getPayload() const
 	return result;
 }
 
-LLMediaDataClient::Responder *LLObjectMediaDataClient::RequestUpdate::createResponder()
+LLHttpSDHandler *LLObjectMediaDataClient::RequestUpdate::createHandler()
 {
 	// This just uses the base class's responder.
-	return new LLMediaDataClient::Responder(this);
+	return new LLMediaDataClient::Handler(this);
 }
 
-
-/*virtual*/
-void LLObjectMediaDataClient::Responder::httpSuccess()
+void LLObjectMediaDataClient::Handler::onSuccess(LLCore::HttpResponse * response, const LLSD &content)
 {
-	getRequest()->stopTracking();
+    LLMediaDataClient::Handler::onSuccess(response, content);
+
+    if (getRequest()->isDead())
+    {   // warning emitted from base method.
+        return;
+    }
+
+    if (!content.isMap())
+    {
+        onFailure(response, LLCore::HttpStatus(HTTP_INTERNAL_ERROR, "Malformed response contents"));
+        return;
+    }
+
+    // This responder is only used for GET requests, not UPDATE.
+    LL_DEBUGS("LLMediaDataClientResponse") << *(getRequest()) << " " << LL_ENDL;
+
+    // Look for an error
+    if (content.has("error"))
+    {
+        const LLSD &error = content["error"];
+        LL_WARNS("LLMediaDataClient") << *(getRequest()) << " Error getting media data for object: code=" << 
+            error["code"].asString() << ": " << error["message"].asString() << LL_ENDL;
+
+        // XXX Warn user?
+    }
+    else 
+    {
+        // Check the data
+        const LLUUID &object_id = content[LLTextureEntry::OBJECT_ID_KEY];
+        if (object_id != getRequest()->getObject()->getID()) 
+        {
+            // NOT good, wrong object id!!
+            LL_WARNS("LLMediaDataClient") << *(getRequest()) << " DROPPING response with wrong object id (" << object_id << ")" << LL_ENDL;
+            return;
+        }
+
+        // Otherwise, update with object media data
+        getRequest()->getObject()->updateObjectMediaData(content[LLTextureEntry::OBJECT_MEDIA_DATA_KEY],
+            content[LLTextureEntry::MEDIA_VERSION_KEY]);
+    }
 
-	if(getRequest()->isDead())
-	{
-		LL_WARNS("LLMediaDataClient") << "dead request " << *(getRequest()) << LL_ENDL;
-		return;
-	}
-
-	const LLSD& content = getContent();
-	if (!content.isMap())
-	{
-		failureResult(HTTP_INTERNAL_ERROR, "Malformed response contents", content);
-		return;
-	}
-
-	// This responder is only used for GET requests, not UPDATE.
-	LL_DEBUGS("LLMediaDataClientResponse") << *(getRequest()) << " " << dumpResponse() << LL_ENDL;
-
-	// Look for an error
-	if (content.has("error"))
-	{
-		const LLSD &error = content["error"];
-		LL_WARNS("LLMediaDataClient") << *(getRequest()) << " Error getting media data for object: code=" << 
-			error["code"].asString() << ": " << error["message"].asString() << LL_ENDL;
-		
-		// XXX Warn user?
-	}
-	else 
-	{
-		// Check the data
-		const LLUUID &object_id = content[LLTextureEntry::OBJECT_ID_KEY];
-		if (object_id != getRequest()->getObject()->getID()) 
-		{
-			// NOT good, wrong object id!!
-			LL_WARNS("LLMediaDataClient") << *(getRequest()) << " DROPPING response with wrong object id (" << object_id << ")" << LL_ENDL;
-			return;
-		}
-		
-		// Otherwise, update with object media data
-		getRequest()->getObject()->updateObjectMediaData(content[LLTextureEntry::OBJECT_MEDIA_DATA_KEY],
-														 content[LLTextureEntry::MEDIA_VERSION_KEY]);
-	}
 }
 
+
 //////////////////////////////////////////////////////////////////////////////////////
 //
 // LLObjectMediaNavigateClient
@@ -947,7 +959,7 @@ void LLObjectMediaNavigateClient::enqueue(Request *request)
 {
 	if(request->isDead())
 	{
-		LL_DEBUGS("LLMediaDataClient") << "not queueing dead request " << *request << LL_ENDL;
+		LL_DEBUGS("LLMediaDataClient") << "not queuing dead request " << *request << LL_ENDL;
 		return;
 	}
 	
@@ -979,7 +991,7 @@ void LLObjectMediaNavigateClient::enqueue(Request *request)
 	else
 #endif
 	{
-		LL_DEBUGS("LLMediaDataClient") << "queueing new request " << (*request) << LL_ENDL;
+		LL_DEBUGS("LLMediaDataClient") << "queuing new request " << (*request) << LL_ENDL;
 		mQueue.push_back(request);
 		
 		// Start the timer if not already running
@@ -1012,75 +1024,67 @@ LLSD LLObjectMediaNavigateClient::RequestNavigate::getPayload() const
 	return result;
 }
 
-LLMediaDataClient::Responder *LLObjectMediaNavigateClient::RequestNavigate::createResponder()
+LLHttpSDHandler *LLObjectMediaNavigateClient::RequestNavigate::createHandler()
 {
-	return new LLObjectMediaNavigateClient::Responder(this);
+	return new LLObjectMediaNavigateClient::Handler(this);
 }
 
-/*virtual*/
-void LLObjectMediaNavigateClient::Responder::httpFailure()
+void LLObjectMediaNavigateClient::Handler::onSuccess(LLCore::HttpResponse * response, const LLSD &content)
 {
-	getRequest()->stopTracking();
+    LLMediaDataClient::Handler::onSuccess(response, content);
 
-	if(getRequest()->isDead())
-	{
-		LL_WARNS("LLMediaDataClient") << "dead request " << *(getRequest()) << LL_ENDL;
-		return;
-	}
+    if (getRequest()->isDead())
+    {   // already warned.
+        return;
+    }
+
+    LL_INFOS("LLMediaDataClient") << *(getRequest()) << " NAVIGATE returned" << LL_ENDL;
+
+    if (content.has("error"))
+    {
+        const LLSD &error = content["error"];
+        int error_code = error["code"];
+
+        if (ERROR_PERMISSION_DENIED_CODE == error_code)
+        {
+            mediaNavigateBounceBack();
+        }
+        else
+        {
+            LL_WARNS("LLMediaDataClient") << *(getRequest()) << " Error navigating: code=" <<
+                error["code"].asString() << ": " << error["message"].asString() << LL_ENDL;
+        }
+
+        // XXX Warn user?
+    }
+    else
+    {
+        // No action required.
+        LL_DEBUGS("LLMediaDataClientResponse") << *(getRequest()) << LL_ENDL;
+    }
 
-	// Bounce back (unless HTTP_SERVICE_UNAVAILABLE, in which case call base
-	// class
-	if (getStatus() == HTTP_SERVICE_UNAVAILABLE)
-	{
-		LLMediaDataClient::Responder::httpFailure();
-	}
-	else
-	{
-		// bounce the face back
-		LL_WARNS("LLMediaDataClient") << *(getRequest()) << " Error navigating: " << dumpResponse() << LL_ENDL;
-		const LLSD &payload = getRequest()->getPayload();
-		// bounce the face back
-		getRequest()->getObject()->mediaNavigateBounceBack((LLSD::Integer)payload[LLTextureEntry::TEXTURE_INDEX_KEY]);
-	}
 }
 
-/*virtual*/
-void LLObjectMediaNavigateClient::Responder::httpSuccess()
+void LLObjectMediaNavigateClient::Handler::onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status)
 {
-	getRequest()->stopTracking();
+    LLMediaDataClient::Handler::onFailure(response, status);
 
-	if(getRequest()->isDead())
-	{
-		LL_WARNS("LLMediaDataClient") << "dead request " << *(getRequest()) << LL_ENDL;
-		return;
-	}
+    if (getRequest()->isDead())
+    {   // already warned.
+        return;
+    }
 
-	LL_INFOS("LLMediaDataClient") << *(getRequest()) << " NAVIGATE returned " << dumpResponse() << LL_ENDL;
-	
-	const LLSD& content = getContent();
-	if (content.has("error"))
-	{
-		const LLSD &error = content["error"];
-		int error_code = error["code"];
-		
-		if (ERROR_PERMISSION_DENIED_CODE == error_code)
-		{
-			LL_WARNS("LLMediaDataClient") << *(getRequest()) << " Navigation denied: bounce back" << LL_ENDL;
-			const LLSD &payload = getRequest()->getPayload();
-			// bounce the face back
-			getRequest()->getObject()->mediaNavigateBounceBack((LLSD::Integer)payload[LLTextureEntry::TEXTURE_INDEX_KEY]);
-		}
-		else
-		{
-			LL_WARNS("LLMediaDataClient") << *(getRequest()) << " Error navigating: code=" << 
-				error["code"].asString() << ": " << error["message"].asString() << LL_ENDL;
-		}			 
+    if (status != LLCore::HttpStatus(HTTP_SERVICE_UNAVAILABLE))
+    {
+        mediaNavigateBounceBack();
+    }
+}
 
-		// XXX Warn user?
-	}
-	else 
-	{
-		// No action required.
-		LL_DEBUGS("LLMediaDataClientResponse") << *(getRequest()) << " " << dumpResponse() << LL_ENDL;
-	}
+void LLObjectMediaNavigateClient::Handler::mediaNavigateBounceBack()
+{
+    LL_WARNS("LLMediaDataClient") << *(getRequest()) << " Error navigating or denied." << LL_ENDL;
+    const LLSD &payload = getRequest()->getPayload();
+    
+    // bounce the face back
+    getRequest()->getObject()->mediaNavigateBounceBack((LLSD::Integer)payload[LLTextureEntry::TEXTURE_INDEX_KEY]);
 }
diff --git a/indra/newview/llmediadataclient.h b/indra/newview/llmediadataclient.h
index 80dd519812..d123aa7a11 100755
--- a/indra/newview/llmediadataclient.h
+++ b/indra/newview/llmediadataclient.h
@@ -32,7 +32,11 @@
 #include "llrefcount.h"
 #include "llpointer.h"
 #include "lleventtimer.h"
-
+#include "llhttpsdhandler.h"
+#include "httpcommon.h"
+#include "httprequest.h"
+#include "httpoptions.h"
+#include "httpheaders.h"
 
 // Link seam for LLVOVolume
 class LLMediaDataClientObject : public LLRefCount
@@ -109,8 +113,6 @@ protected:
 	// Destructor
 	virtual ~LLMediaDataClient(); // use unref
     
-	class Responder;
-	
 	// Request (pure virtual base class for requests in the queue)
 	class Request : public LLRefCount
 	{
@@ -118,7 +120,7 @@ protected:
 		// Subclasses must implement this to build a payload for their request type.
 		virtual LLSD getPayload() const = 0;
 		// and must create the correct type of responder.
-		virtual Responder *createResponder() = 0;
+        virtual LLHttpSDHandler *createHandler() = 0;
 
 		virtual std::string getURL() { return ""; }
 
@@ -190,23 +192,21 @@ protected:
 	};
 	typedef LLPointer<Request> request_ptr_t;
 
-	// Responder
-	class Responder : public LLHTTPClient::Responder
-	{
-		LOG_CLASS(Responder);
-	public:
-		Responder(const request_ptr_t &request);
-		request_ptr_t &getRequest() { return mRequest; }
+    class Handler : public LLHttpSDHandler
+    {
+        LOG_CLASS(Handler);
+    public:
+        Handler(const request_ptr_t &request);
+        request_ptr_t getRequest() const { return mRequest; }
 
-	protected:
-		//If we get back an error (not found, etc...), handle it here
-		virtual void httpFailure();
-		//If we get back a normal response, handle it here.	 Default just logs it.
-		virtual void httpSuccess();
+    protected:
+        virtual void onSuccess(LLCore::HttpResponse * response, const LLSD &content);
+        virtual void onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status);
+
+    private:
+        request_ptr_t mRequest;
+    };
 
-	private:
-		request_ptr_t mRequest;
-	};
 
 	class RetryTimer : public LLEventTimer
 	{
@@ -230,6 +230,7 @@ protected:
 	virtual void enqueue(Request*) = 0;
 	
 	virtual void serviceQueue();
+    virtual void serviceHttp();
 
 	virtual request_queue_t *getQueue() { return &mQueue; };
 
@@ -243,6 +244,8 @@ protected:
 	
 	void trackRequest(request_ptr_t request);
 	void stopTrackingRequest(request_ptr_t request);
+
+    bool isDoneProcessing() const;
 	
 	request_queue_t mQueue;
 
@@ -260,6 +263,11 @@ protected:
 	void startQueueTimer();
 	void stopQueueTimer();
 
+    LLCore::HttpRequest::ptr_t  mHttpRequest;
+    LLCore::HttpHeaders::ptr_t  mHttpHeaders;
+    LLCore::HttpOptions::ptr_t  mHttpOpts;
+    LLCore::HttpRequest::policy_t mHttpPolicy;
+
 private:
 	
 	static F64 getObjectScore(const LLMediaDataClientObject::ptr_t &obj);
@@ -309,7 +317,7 @@ public:
 	public:
 		RequestGet(LLMediaDataClientObject *obj, LLMediaDataClient *mdc);
 		/*virtual*/ LLSD getPayload() const;
-		/*virtual*/ Responder *createResponder();
+        /*virtual*/ LLHttpSDHandler *createHandler();
 	};
 
 	class RequestUpdate: public Request
@@ -317,7 +325,7 @@ public:
 	public:
 		RequestUpdate(LLMediaDataClientObject *obj, LLMediaDataClient *mdc);
 		/*virtual*/ LLSD getPayload() const;
-		/*virtual*/ Responder *createResponder();
+        /*virtual*/ LLHttpSDHandler *createHandler();
 	};
 
 	// Returns true iff the queue is empty
@@ -342,15 +350,18 @@ protected:
 	// Puts the request into the appropriate queue
 	virtual void enqueue(Request*);
 		    
-    class Responder : public LLMediaDataClient::Responder
+    class Handler: public LLMediaDataClient::Handler
     {
-        LOG_CLASS(Responder);
+        LOG_CLASS(Handler);
     public:
-        Responder(const request_ptr_t &request)
-            : LLMediaDataClient::Responder(request) {}
+        Handler(const request_ptr_t &request):
+            LLMediaDataClient::Handler(request)
+        {}
+
     protected:
-        virtual void httpSuccess();
+        virtual void onSuccess(LLCore::HttpResponse * response, const LLSD &content);
     };
+
 private:
 	// The Get/Update data client needs a second queue to avoid object updates starving load-ins.
 	void swapCurrentQueue();
@@ -391,7 +402,7 @@ public:
 	public:
 		RequestNavigate(LLMediaDataClientObject *obj, LLMediaDataClient *mdc, U8 texture_index, const std::string &url);
 		/*virtual*/ LLSD getPayload() const;
-		/*virtual*/ Responder *createResponder();
+        /*virtual*/ LLHttpSDHandler *createHandler();
 		/*virtual*/ std::string getURL() { return mURL; }
 	private:
 		std::string mURL;
@@ -401,15 +412,18 @@ protected:
 	// Subclasses must override to return a cap name
 	virtual const char *getCapabilityName() const;
 
-    class Responder : public LLMediaDataClient::Responder
+    class Handler : public LLMediaDataClient::Handler
     {
-        LOG_CLASS(Responder);
+        LOG_CLASS(Handler);
     public:
-        Responder(const request_ptr_t &request)
-            : LLMediaDataClient::Responder(request) {}
+        Handler(const request_ptr_t &request):
+            LLMediaDataClient::Handler(request)
+        {}
+
     protected:
-        virtual void httpFailure();
-        virtual void httpSuccess();
+        virtual void onSuccess(LLCore::HttpResponse * response, const LLSD &content);
+        virtual void onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status);
+
     private:
         void mediaNavigateBounceBack();
     };
-- 
cgit v1.3


From c437a9c4ec865c38366c8057010d24311888ecb1 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 20 May 2015 17:37:27 -0700
Subject: Webprofile converted to coroutine. Added JSON->LLSD converter Added
 corohandler for JSON data

---
 indra/llcommon/CMakeLists.txt      |   5 +
 indra/llcommon/llsdjson.cpp        |  78 ++++++++
 indra/llcommon/llsdjson.h          |  59 ++++++
 indra/llcorehttp/httpheaders.cpp   |  18 ++
 indra/llcorehttp/httpheaders.h     |   6 +-
 indra/llmessage/CMakeLists.txt     |   4 +
 indra/llmessage/llcorehttputil.cpp |  82 ++++++++
 indra/llmessage/llcorehttputil.h   |  12 ++
 indra/newview/llwebprofile.cpp     | 372 ++++++++++++++++++-------------------
 indra/newview/llwebprofile.h       |  12 +-
 10 files changed, 449 insertions(+), 199 deletions(-)
 create mode 100644 indra/llcommon/llsdjson.cpp
 create mode 100644 indra/llcommon/llsdjson.h

(limited to 'indra/llcorehttp')

diff --git a/indra/llcommon/CMakeLists.txt b/indra/llcommon/CMakeLists.txt
index 1459b9ada2..9086691375 100755
--- a/indra/llcommon/CMakeLists.txt
+++ b/indra/llcommon/CMakeLists.txt
@@ -8,6 +8,7 @@ include(LLCommon)
 include(Linking)
 include(Boost)
 include(LLSharedLibs)
+include(JsonCpp)
 include(GoogleBreakpad)
 include(GooglePerfTools)
 include(Copy3rdPartyLibs)
@@ -17,6 +18,7 @@ include(URIPARSER)
 include_directories(
     ${EXPAT_INCLUDE_DIRS}
     ${LLCOMMON_INCLUDE_DIRS}
+    ${JSONCPP_INCLUDE_DIR}
     ${ZLIB_INCLUDE_DIRS}
     ${BREAKPAD_INCLUDE_DIRECTORIES}
     ${URIPARSER_INCLUDE_DIRS}
@@ -85,6 +87,7 @@ set(llcommon_SOURCE_FILES
     llrefcount.cpp
     llrun.cpp
     llsd.cpp
+	llsdjson.cpp
     llsdparam.cpp
     llsdserialize.cpp
     llsdserialize_xml.cpp
@@ -193,6 +196,7 @@ set(llcommon_HEADER_FILES
     llrefcount.h
     llsafehandle.h
     llsd.h
+	llsdjson.h
     llsdparam.h
     llsdserialize.h
     llsdserialize_xml.h
@@ -260,6 +264,7 @@ target_link_libraries(
     ${APRUTIL_LIBRARIES}
     ${APR_LIBRARIES}
     ${EXPAT_LIBRARIES}
+    ${JSONCPP_LIBRARIES}
     ${ZLIB_LIBRARIES}
     ${WINDOWS_LIBRARIES}
     ${BOOST_PROGRAM_OPTIONS_LIBRARY}
diff --git a/indra/llcommon/llsdjson.cpp b/indra/llcommon/llsdjson.cpp
new file mode 100644
index 0000000000..2afdba388a
--- /dev/null
+++ b/indra/llcommon/llsdjson.cpp
@@ -0,0 +1,78 @@
+/** 
+ * @file llsdjson.cpp
+ * @brief LLSD flexible data system
+ *
+ * $LicenseInfo:firstyear=2015&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2015, 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$
+ */
+
+// Must turn on conditional declarations in header file so definitions end up
+// with proper linkage.
+#define LLSD_DEBUG_INFO
+#include "linden_common.h"
+
+#include "llsdjson.h"
+
+#include "llerror.h"
+#include "../llmath/llmath.h"
+
+//=========================================================================
+LLSD LlsdFromJson(const Json::Value &val)
+{
+    LLSD result;
+
+    switch (val.type())
+    {
+    default:
+    case Json::nullValue:
+        break;
+    case Json::intValue:
+        result = LLSD(static_cast<LLSD::Integer>(val.asInt()));
+        break;
+    case Json::uintValue:
+        result = LLSD(static_cast<LLSD::Integer>(val.asUInt()));
+        break;
+    case Json::realValue:
+        result = LLSD(static_cast<LLSD::Real>(val.asDouble()));
+        break;
+    case Json::stringValue:
+        result = LLSD(static_cast<LLSD::String>(val.asString()));
+        break;
+    case Json::booleanValue:
+        result = LLSD(static_cast<LLSD::Boolean>(val.asBool()));
+        break;
+    case Json::arrayValue:
+        result = LLSD::emptyArray();
+        for (Json::ValueConstIterator it = val.begin(); it != val.end(); ++it)
+        {
+            result.append(LlsdFromJson((*it)));
+        }
+        break;
+    case Json::objectValue:
+        result = LLSD::emptyMap();
+        for (Json::ValueConstIterator it = val.begin(); it != val.end(); ++it)
+        {
+            result[it.memberName()] = LlsdFromJson((*it));
+        }
+        break;
+    }
+    return result;
+}
diff --git a/indra/llcommon/llsdjson.h b/indra/llcommon/llsdjson.h
new file mode 100644
index 0000000000..cdf9fed500
--- /dev/null
+++ b/indra/llcommon/llsdjson.h
@@ -0,0 +1,59 @@
+/** 
+ * @file llsdjson.cpp
+ * @brief LLSD flexible data system
+ *
+ * $LicenseInfo:firstyear=2015&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2015, 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_LLSDJSON_H
+#define LL_LLSDJSON_H
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "stdtypes.h"
+
+#include "llsd.h"
+#include "value.h"
+
+/// Convert a parsed JSON structure into LLSD maintaining member names and 
+/// array indexes.
+/// JSON/JavaScript types are converted as follows:
+/// 
+/// JSON Type     | LLSD Type
+/// --------------+--------------
+///  null         |  undefined
+///  integer      |  LLSD::Integer
+///  unsigned     |  LLSD::Integer
+///  real/numeric |  LLSD::Real
+///  string       |  LLSD::String
+///  boolean      |  LLSD::Boolean
+///  array        |  LLSD::Array
+///  object       |  LLSD::Map
+///  
+/// For maps and arrays child entries will be converted and added to the structure.
+/// Order is preserved for an array but not for objects.
+LLSD LlsdFromJson(const Json::Value &val);
+
+
+#endif // LL_LLSDJSON_H
diff --git a/indra/llcorehttp/httpheaders.cpp b/indra/llcorehttp/httpheaders.cpp
index 73c92c8f10..e03b1b080d 100755
--- a/indra/llcorehttp/httpheaders.cpp
+++ b/indra/llcorehttp/httpheaders.cpp
@@ -118,6 +118,24 @@ const std::string * HttpHeaders::find(const std::string &name) const
 	return NULL;
 }
 
+void HttpHeaders::remove(const char *name)
+{
+    remove(std::string(name));
+}
+
+void HttpHeaders::remove(const std::string &name)
+{
+    iterator iend(end());
+    for (iterator iter(begin()); iend != iter; ++iter)
+    {
+        if ((*iter).first == name)
+        {
+            mHeaders.erase(iter);
+            return;
+        }
+    }
+}
+
 
 // Standard Iterators
 HttpHeaders::iterator HttpHeaders::begin()
diff --git a/indra/llcorehttp/httpheaders.h b/indra/llcorehttp/httpheaders.h
index 940f92183c..51bd76a01d 100755
--- a/indra/llcorehttp/httpheaders.h
+++ b/indra/llcorehttp/httpheaders.h
@@ -146,13 +146,17 @@ public:
 	//					a pointer to a std::string in the container.
 	//					Pointer is valid only for the lifetime of
 	//					the container or until container is modifed.
-	
 	const std::string * find(const std::string &name) const;
 	const std::string * find(const char * name) const
 	{
 		return find(std::string(name));
 	}
 
+    // Remove the header from the list if found.
+    // 
+    void remove(const std::string &name);
+    void remove(const char *name);
+
 	// Count of headers currently in the list.
 	size_type size() const
 		{
diff --git a/indra/llmessage/CMakeLists.txt b/indra/llmessage/CMakeLists.txt
index f6ca6a3634..51b8ed6c62 100755
--- a/indra/llmessage/CMakeLists.txt
+++ b/indra/llmessage/CMakeLists.txt
@@ -14,6 +14,7 @@ include(LLAddBuildTest)
 include(Python)
 include(Tut)
 include(Python)
+include(JsonCpp)
 
 include_directories (${CMAKE_CURRENT_SOURCE_DIR})
 
@@ -23,6 +24,7 @@ include_directories(
     ${LLMATH_INCLUDE_DIRS}
     ${LLMESSAGE_INCLUDE_DIRS}
     ${LLVFS_INCLUDE_DIRS}
+    ${JSONCPP_INCLUDE_DIR}
     )
 
 set(llmessage_SOURCE_FILES
@@ -229,6 +231,7 @@ target_link_libraries(
   ${LLVFS_LIBRARIES}
   ${LLMATH_LIBRARIES}
   ${CARES_LIBRARIES}
+  ${JSONCPP_LIBRARIES}
   ${OPENSSL_LIBRARIES}
   ${CRYPTO_LIBRARIES}
   ${XMLRPCEPI_LIBRARIES}
@@ -254,6 +257,7 @@ if (LL_TESTS)
     ${LLCOMMON_LIBRARIES}
     ${LLMESSAGE_LIBRARIES}
     ${LLCOREHTTP_LIBRARIES}
+    ${JSONCPP_LIBRARIES}
     ${BOOST_CONTEXT_LIBRARY}
     ${BOOST_COROUTINE_LIBRARY}
     ${GOOGLEMOCK_LIBRARIES}
diff --git a/indra/llmessage/llcorehttputil.cpp b/indra/llmessage/llcorehttputil.cpp
index cf34029dfe..05d2e84f88 100644
--- a/indra/llmessage/llcorehttputil.cpp
+++ b/indra/llmessage/llcorehttputil.cpp
@@ -32,7 +32,10 @@
 #include <iterator>
 #include "llcorehttputil.h"
 #include "llhttpconstants.h"
+#include "llsd.h"
+#include "llsdjson.h"
 #include "llsdserialize.h"
+#include "reader.h" 
 
 using namespace LLCore;
 
@@ -252,6 +255,23 @@ void HttpCoroHandler::onCompleted(LLCore::HttpHandle handle, LLCore::HttpRespons
     }
 
     buildStatusEntry(response, status, result);
+
+#if 0
+    // commenting out, but keeping since this can be useful for debugging
+    if (!status)
+    {
+        LLSD &httpStatus = result[HttpCoroutineAdapter::HTTP_RESULTS];
+
+        LLCore::BufferArray *body = response->getBody();
+        LLCore::BufferArrayStream bas(body);
+        LLSD::Binary bodyData;
+        bodyData.reserve(response->getBodySize());
+        bas >> std::noskipws;
+        bodyData.assign(std::istream_iterator<U8>(bas), std::istream_iterator<U8>());
+        httpStatus["error_body"] = bodyData;
+    }
+#endif
+
     mReplyPump.post(result);
 }
 
@@ -437,6 +457,58 @@ LLSD HttpCoroRawHandler::handleSuccess(LLCore::HttpResponse * response, LLCore::
     return result;
 }
 
+//========================================================================
+/// The HttpCoroJSONHandler is a specialization of the LLCore::HttpHandler for 
+/// interacting with coroutines. 
+/// 
+/// In addition to the normal "http_results" the returned LLSD will contain 
+/// JSON entries will be converted into an LLSD map.  All results are considered 
+/// strings
+///                      
+class HttpCoroJSONHandler : public HttpCoroHandler
+{
+public:
+    HttpCoroJSONHandler(LLEventStream &reply);
+
+    virtual LLSD handleSuccess(LLCore::HttpResponse * response, LLCore::HttpStatus &status);
+};
+
+//-------------------------------------------------------------------------
+HttpCoroJSONHandler::HttpCoroJSONHandler(LLEventStream &reply) :
+    HttpCoroHandler(reply)
+{
+}
+
+LLSD HttpCoroJSONHandler::handleSuccess(LLCore::HttpResponse * response, LLCore::HttpStatus &status)
+{
+    LLSD result = LLSD::emptyMap();
+
+    BufferArray * body(response->getBody());
+    if (!body || !body->size())
+    {
+        return result;
+    }
+
+    LLCore::BufferArrayStream bas(body);
+    Json::Value jsonRoot;
+
+    try
+    {
+        bas >> jsonRoot;
+    }
+    catch (std::runtime_error e)
+    {   // deserialization failed.  Record the reason and pass back an empty map for markup.
+        status = LLCore::HttpStatus(499, std::string(e.what()));
+        return result;
+    }
+
+    // Convert the JSON structure to LLSD
+    result = LlsdFromJson(jsonRoot);
+
+    return result;
+}
+
+
 //========================================================================
 HttpRequestPumper::HttpRequestPumper(const LLCore::HttpRequest::ptr_t &request) :
     mHttpRequest(request)
@@ -614,6 +686,16 @@ LLSD HttpCoroutineAdapter::getRawAndYield(LLCoros::self & self, LLCore::HttpRequ
     return getAndYield_(self, request, url, options, headers, httpHandler);
 }
 
+LLSD HttpCoroutineAdapter::getJsonAndYield(LLCoros::self & self, 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 = HttpCoroHandler::ptr_t(new HttpCoroJSONHandler(replyPump));
+
+    return getAndYield_(self, request, url, options, headers, httpHandler);
+}
+
+
 LLSD HttpCoroutineAdapter::getAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
     const std::string & url,
     LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers, 
diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 35e5b0aa2d..d6219318f9 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -373,6 +373,18 @@ public:
             headers);
     }
 
+    LLSD getJsonAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+        const std::string & url,
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+    LLSD getJsonndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
+    {
+        return getJsonAndYield(self, request, url,
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+            headers);
+    }
+
 
     /// Execute a DELETE transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available.
diff --git a/indra/newview/llwebprofile.cpp b/indra/newview/llwebprofile.cpp
index ddb7f7bfce..3d371e629f 100755
--- a/indra/newview/llwebprofile.cpp
+++ b/indra/newview/llwebprofile.cpp
@@ -34,10 +34,14 @@
 #include "llimagepng.h"
 #include "llplugincookiestore.h"
 
+#include "llsdserialize.h"
+
 // newview
 #include "llpanelprofile.h" // for getProfileURL(). FIXME: move the method to LLAvatarActions
 #include "llviewermedia.h" // FIXME: don't use LLViewerMedia internals
 
+#include "llcorehttputil.h"
+
 // third-party
 #include "reader.h" // JSON
 
@@ -54,139 +58,6 @@
  *    -> GET <redirect_url> via PostImageRedirectResponder
  */
 
-///////////////////////////////////////////////////////////////////////////////
-// LLWebProfileResponders::ConfigResponder
-
-class LLWebProfileResponders::ConfigResponder : public LLHTTPClient::Responder
-{
-	LOG_CLASS(LLWebProfileResponders::ConfigResponder);
-
-public:
-	ConfigResponder(LLPointer<LLImageFormatted> imagep)
-	:	mImagep(imagep)
-	{
-	}
-
-	// *TODO: Check for 'application/json' content type, and parse json at the base class.
-	/*virtual*/ void completedRaw(
-		const LLChannelDescriptors& channels,
-		const LLIOPipe::buffer_ptr_t& buffer)
-	{
-		LLBufferStream istr(channels, buffer.get());
-		std::stringstream strstrm;
-		strstrm << istr.rdbuf();
-		const std::string body = strstrm.str();
-
-		if (getStatus() != HTTP_OK)
-		{
-			LL_WARNS() << "Failed to get upload config " << dumpResponse() << LL_ENDL;
-			LLWebProfile::reportImageUploadStatus(false);
-			return;
-		}
-
-		Json::Value root;
-		Json::Reader reader;
-		if (!reader.parse(body, root))
-		{
-			LL_WARNS() << "Failed to parse upload config: " << reader.getFormatedErrorMessages() << LL_ENDL;
-			LLWebProfile::reportImageUploadStatus(false);
-			return;
-		}
-
-		// *TODO: 404 = not supported by the grid
-		// *TODO: increase timeout or handle 499 Expired
-
-		// Convert config to LLSD.
-		const Json::Value data = root["data"];
-		const std::string upload_url = root["url"].asString();
-		LLSD config;
-		config["acl"]						= data["acl"].asString();
-		config["AWSAccessKeyId"]			= data["AWSAccessKeyId"].asString();
-		config["Content-Type"]				= data["Content-Type"].asString();
-		config["key"]						= data["key"].asString();
-		config["policy"]					= data["policy"].asString();
-		config["success_action_redirect"]	= data["success_action_redirect"].asString();
-		config["signature"]					= data["signature"].asString();
-		config["add_loc"]					= data.get("add_loc", "0").asString();
-		config["caption"]					= data.get("caption", "").asString();
-
-		// Do the actual image upload using the configuration.
-		LL_DEBUGS("Snapshots") << "Got upload config, POSTing image to " << upload_url << ", config=[" << config << "]" << LL_ENDL;
-		LLWebProfile::post(mImagep, config, upload_url);
-	}
-
-private:
-	LLPointer<LLImageFormatted> mImagep;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// LLWebProfilePostImageRedirectResponder
-class LLWebProfileResponders::PostImageRedirectResponder : public LLHTTPClient::Responder
-{
-	LOG_CLASS(LLWebProfileResponders::PostImageRedirectResponder);
-
-public:
-	/*virtual*/ void completedRaw(
-		const LLChannelDescriptors& channels,
-		const LLIOPipe::buffer_ptr_t& buffer)
-	{
-		if (getStatus() != HTTP_OK)
-		{
-			LL_WARNS() << "Failed to upload image " << dumpResponse() << LL_ENDL;
-			LLWebProfile::reportImageUploadStatus(false);
-			return;
-		}
-
-		LLBufferStream istr(channels, buffer.get());
-		std::stringstream strstrm;
-		strstrm << istr.rdbuf();
-		const std::string body = strstrm.str();
-		LL_INFOS() << "Image uploaded." << LL_ENDL;
-		LL_DEBUGS("Snapshots") << "Uploading image succeeded. Response: [" << body << "]" << LL_ENDL;
-		LLWebProfile::reportImageUploadStatus(true);
-	}
-};
-
-
-///////////////////////////////////////////////////////////////////////////////
-// LLWebProfileResponders::PostImageResponder
-class LLWebProfileResponders::PostImageResponder : public LLHTTPClient::Responder
-{
-	LOG_CLASS(LLWebProfileResponders::PostImageResponder);
-
-public:
-	/*virtual*/ void completedRaw(const LLChannelDescriptors& channels,
-								  const LLIOPipe::buffer_ptr_t& buffer)
-	{
-		// Viewer seems to fail to follow a 303 redirect on POST request
-		// (URLRequest Error: 65, Send failed since rewinding of the data stream failed).
-		// Handle it manually.
-		if (getStatus() == HTTP_SEE_OTHER)
-		{
-			LLSD headers = LLViewerMedia::getHeaders();
-			headers[HTTP_OUT_HEADER_COOKIE] = LLWebProfile::getAuthCookie();
-			const std::string& redir_url = getResponseHeader(HTTP_IN_HEADER_LOCATION);
-			if (redir_url.empty())
-			{
-				LL_WARNS() << "Received empty redirection URL " << dumpResponse() << LL_ENDL;
-				LL_DEBUGS("Snapshots") << "[headers:" << getResponseHeaders() << "]" << LL_ENDL;
-				LLWebProfile::reportImageUploadStatus(false);
-			}
-			else
-			{
-				LL_DEBUGS("Snapshots") << "Got redirection URL: " << redir_url << LL_ENDL;
-				LLHTTPClient::get(redir_url, new LLWebProfileResponders::PostImageRedirectResponder, headers);
-			}
-		}
-		else
-		{
-			LL_WARNS() << "Unexpected POST response " << dumpResponse() << LL_ENDL;
-			LL_DEBUGS("Snapshots") << "[headers:" << getResponseHeaders() << "]" << LL_ENDL;
-			LLWebProfile::reportImageUploadStatus(false);
-		}
-	}
-};
-
 ///////////////////////////////////////////////////////////////////////////////
 // LLWebProfile
 
@@ -196,15 +67,9 @@ LLWebProfile::status_callback_t LLWebProfile::mStatusCallback;
 // static
 void LLWebProfile::uploadImage(LLPointer<LLImageFormatted> image, const std::string& caption, bool add_location)
 {
-	// Get upload configuration data.
-	std::string config_url(getProfileURL(LLStringUtil::null) + "snapshots/s3_upload_config");
-	config_url += "?caption=" + LLURI::escape(caption);
-	config_url += "&add_loc=" + std::string(add_location ? "1" : "0");
-
-	LL_DEBUGS("Snapshots") << "Requesting " << config_url << LL_ENDL;
-	LLSD headers = LLViewerMedia::getHeaders();
-	headers[HTTP_OUT_HEADER_COOKIE] = getAuthCookie();
-	LLHTTPClient::get(config_url, new LLWebProfileResponders::ConfigResponder(image), headers);
+    LLCoros::instance().launch("LLWebProfile::uploadImageCoro",
+        boost::bind(&LLWebProfile::uploadImageCoro, _1, image, caption, add_location));
+
 }
 
 // static
@@ -214,74 +79,193 @@ void LLWebProfile::setAuthCookie(const std::string& cookie)
 	sAuthCookie = cookie;
 }
 
-// static
-void LLWebProfile::post(LLPointer<LLImageFormatted> image, const LLSD& config, const std::string& url)
+
+/*static*/
+LLCore::HttpHeaders::ptr_t LLWebProfile::buildDefaultHeaders()
 {
-	if (dynamic_cast<LLImagePNG*>(image.get()) == 0)
-	{
-		LL_WARNS() << "Image to upload is not a PNG" << LL_ENDL;
-		llassert(dynamic_cast<LLImagePNG*>(image.get()) != 0);
-		return;
-	}
+    LLCore::HttpHeaders::ptr_t httpHeaders(new LLCore::HttpHeaders);
+    LLSD headers = LLViewerMedia::getHeaders();
 
-	const std::string boundary = "----------------------------0123abcdefab";
+    for (LLSD::map_iterator it = headers.beginMap(); it != headers.endMap(); ++it)
+    {
+        httpHeaders->append((*it).first, (*it).second.asStringRef());
+    }
 
-	LLSD headers = LLViewerMedia::getHeaders();
-	headers[HTTP_OUT_HEADER_COOKIE] = getAuthCookie();
-	headers[HTTP_OUT_HEADER_CONTENT_TYPE] = "multipart/form-data; boundary=" + boundary;
+    return httpHeaders;
+}
 
-	std::ostringstream body;
 
-	// *NOTE: The order seems to matter.
-	body	<< "--" << boundary << "\r\n"
-			<< "Content-Disposition: form-data; name=\"key\"\r\n\r\n"
-			<< config["key"].asString() << "\r\n";
+/*static*/
+void LLWebProfile::uploadImageCoro(LLCoros::self& self, LLPointer<LLImageFormatted> image, std::string caption, bool addLocation)
+{
+    LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
+    LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
+        httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("genericPostCoro", httpPolicy));
+    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
+    LLCore::HttpHeaders::ptr_t httpHeaders;
+
+    if (dynamic_cast<LLImagePNG*>(image.get()) == 0)
+    {
+        LL_WARNS() << "Image to upload is not a PNG" << LL_ENDL;
+        llassert(dynamic_cast<LLImagePNG*>(image.get()) != 0);
+        return;
+    }
+
+    httpOpts->setWantHeaders(true);
+
+    // Get upload configuration data.
+    std::string configUrl(getProfileURL(std::string()) + "snapshots/s3_upload_config");
+    configUrl += "?caption=" + LLURI::escape(caption);
+    configUrl += "&add_loc=" + std::string(addLocation ? "1" : "0");
+
+    LL_DEBUGS("Snapshots") << "Requesting " << configUrl << LL_ENDL;
+
+    httpHeaders = buildDefaultHeaders();
+    httpHeaders->append(HTTP_OUT_HEADER_COOKIE, getAuthCookie());
+
+    LLSD result = httpAdapter->getJsonAndYield(self, httpRequest, configUrl, httpOpts, httpHeaders);
+
+    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
+    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
+
+    if (!status)
+    {
+        std::ostringstream ostm;
+        LLSDSerialize::toPrettyXML(httpResults, ostm);
+        LL_WARNS("Snapshots") << "Failed to get image upload config" << LL_ENDL;
+        LL_WARNS("Snapshots") << ostm.str() << LL_ENDL;
+        LLWebProfile::reportImageUploadStatus(false);
+        return;
+    }
+
+    // Ready to build our image post body.
+
+    const LLSD &data = result["data"];
+    const std::string &uploadUrl = result["url"].asStringRef();
+    const std::string boundary = "----------------------------0123abcdefab";
+
+    // a new set of headers.
+    httpHeaders = buildDefaultHeaders();
+    httpHeaders->append(HTTP_OUT_HEADER_COOKIE, getAuthCookie());
+    httpHeaders->remove(HTTP_OUT_HEADER_CONTENT_TYPE);
+    httpHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, "multipart/form-data; boundary=" + boundary);
+    
+    LLCore::BufferArray::ptr_t body = LLWebProfile::buildPostData(data, image, boundary);
+
+    result = httpAdapter->postAndYield(self, httpRequest, uploadUrl, body, httpOpts, httpHeaders);
+
+    {
+        std::ostringstream ostm;
+        LLSDSerialize::toPrettyXML(result, ostm);
+        LL_WARNS("Snapshots") << ostm.str() << LL_ENDL;
+    }
+    body.reset();
+    httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
+    status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
+
+    if (!status && (status != LLCore::HttpStatus(HTTP_SEE_OTHER)))
+    {
+        LL_WARNS("Snapshots") << "Failed to upload image data." << LL_ENDL;
+        LLWebProfile::reportImageUploadStatus(false);
+        return;
+    }
+
+    LLSD resultHeaders = httpResults[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS_HEADERS];
+
+    httpHeaders = buildDefaultHeaders();
+    httpHeaders->append(HTTP_OUT_HEADER_COOKIE, getAuthCookie());
+
+    const std::string& redirUrl = resultHeaders[HTTP_IN_HEADER_LOCATION].asStringRef();
+
+    if (redirUrl.empty())
+    {
+        LL_WARNS("Snapshots") << "Received empty redirection URL in post image." << LL_ENDL;
+        LLWebProfile::reportImageUploadStatus(false);
+    }
+
+    LL_DEBUGS("Snapshots") << "Got redirection URL: " << redirUrl << LL_ENDL;
+
+    result = httpAdapter->getRawAndYield(self, httpRequest, redirUrl, httpOpts, httpHeaders);
+
+    httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
+    status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
+
+    if (status != LLCore::HttpStatus(HTTP_OK))
+    {
+        LL_WARNS("Snapshots") << "Failed to upload image." << LL_ENDL;
+        LLWebProfile::reportImageUploadStatus(false);
+        return;
+    }
+
+    LLSD raw = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS_RAW];
+//    const LLSD::Binary &rawBin = raw.asBinary();
+//    std::istringstream rawresult(rawBin.begin(), rawBin.end());
+
+//    LLBufferStream istr(channels, buffer.get());
+//     std::stringstream strstrm;
+//     strstrm << istr.rdbuf();
+//     const std::string body = strstrm.str();
+    LL_INFOS("Snapshots") << "Image uploaded." << LL_ENDL;
+    LL_DEBUGS("Snapshots") << "Uploading image succeeded. Response: [" << raw.asString() << "]" << LL_ENDL;
+    LLWebProfile::reportImageUploadStatus(true);
 
-	body	<< "--" << boundary << "\r\n"
-			<< "Content-Disposition: form-data; name=\"AWSAccessKeyId\"\r\n\r\n"
-			<< config["AWSAccessKeyId"].asString() << "\r\n";
 
-	body	<< "--" << boundary << "\r\n"
-			<< "Content-Disposition: form-data; name=\"acl\"\r\n\r\n"
-			<< config["acl"].asString() << "\r\n";
+}
 
-	body	<< "--" << boundary << "\r\n"
-			<< "Content-Disposition: form-data; name=\"Content-Type\"\r\n\r\n"
-			<< config["Content-Type"].asString() << "\r\n";
+/*static*/
+LLCore::BufferArray::ptr_t LLWebProfile::buildPostData(const LLSD &data, LLPointer<LLImageFormatted> &image, const std::string &boundary)
+{
+    LLCore::BufferArray::ptr_t body(new LLCore::BufferArray);
+    LLCore::BufferArrayStream bas(body.get());
 
-	body	<< "--" << boundary << "\r\n"
-			<< "Content-Disposition: form-data; name=\"policy\"\r\n\r\n"
-			<< config["policy"].asString() << "\r\n";
+    //    std::ostringstream body;
 
-	body	<< "--" << boundary << "\r\n"
-			<< "Content-Disposition: form-data; name=\"signature\"\r\n\r\n"
-			<< config["signature"].asString() << "\r\n";
+    // *NOTE: The order seems to matter.
+    bas << "--" << boundary << "\r\n"
+        << "Content-Disposition: form-data; name=\"key\"\r\n\r\n"
+        << data["key"].asString() << "\r\n";
 
-	body	<< "--" << boundary << "\r\n"
-			<< "Content-Disposition: form-data; name=\"success_action_redirect\"\r\n\r\n"
-			<< config["success_action_redirect"].asString() << "\r\n";
+    bas << "--" << boundary << "\r\n"
+        << "Content-Disposition: form-data; name=\"AWSAccessKeyId\"\r\n\r\n"
+        << data["AWSAccessKeyId"].asString() << "\r\n";
 
-	body	<< "--" << boundary << "\r\n"
-			<< "Content-Disposition: form-data; name=\"file\"; filename=\"snapshot.png\"\r\n"
-			<< "Content-Type: image/png\r\n\r\n";
+    bas << "--" << boundary << "\r\n"
+        << "Content-Disposition: form-data; name=\"acl\"\r\n\r\n"
+        << data["acl"].asString() << "\r\n";
 
-	// Insert the image data.
-	// *FIX: Treating this as a string will probably screw it up ...
-	U8* image_data = image->getData();
-	for (S32 i = 0; i < image->getDataSize(); ++i)
-	{
-		body << image_data[i];
-	}
+    bas << "--" << boundary << "\r\n"
+        << "Content-Disposition: form-data; name=\"Content-Type\"\r\n\r\n"
+        << data["Content-Type"].asString() << "\r\n";
+
+    bas << "--" << boundary << "\r\n"
+        << "Content-Disposition: form-data; name=\"policy\"\r\n\r\n"
+        << data["policy"].asString() << "\r\n";
+
+    bas << "--" << boundary << "\r\n"
+        << "Content-Disposition: form-data; name=\"signature\"\r\n\r\n"
+        << data["signature"].asString() << "\r\n";
+
+    bas << "--" << boundary << "\r\n"
+        << "Content-Disposition: form-data; name=\"success_action_redirect\"\r\n\r\n"
+        << data["success_action_redirect"].asString() << "\r\n";
+
+    bas << "--" << boundary << "\r\n"
+        << "Content-Disposition: form-data; name=\"file\"; filename=\"snapshot.png\"\r\n"
+        << "Content-Type: image/png\r\n\r\n";
 
-	body <<	"\r\n--" << boundary << "--\r\n";
+    // Insert the image data.
+    //char *datap = (char *)(image->getData());
+    //bas.write(datap, image->getDataSize());
+    U8* image_data = image->getData();
+    for (S32 i = 0; i < image->getDataSize(); ++i)
+    {
+        bas << image_data[i];
+    }
 
-	// postRaw() takes ownership of the buffer and releases it later.
-	size_t size = body.str().size();
-	U8 *data = new U8[size];
-	memcpy(data, body.str().data(), size);
+    bas << "\r\n--" << boundary << "--\r\n";
 
-	// Send request, successful upload will trigger posting metadata.
-	LLHTTPClient::postRaw(url, data, size, new LLWebProfileResponders::PostImageResponder(), headers);
+    return body;
 }
 
 // static
diff --git a/indra/newview/llwebprofile.h b/indra/newview/llwebprofile.h
index 10279bffac..604ef7aff7 100755
--- a/indra/newview/llwebprofile.h
+++ b/indra/newview/llwebprofile.h
@@ -28,6 +28,10 @@
 #define LL_LLWEBPROFILE_H
 
 #include "llimage.h"
+#include "lleventcoro.h"
+#include "llcoros.h"
+#include "httpheaders.h"
+#include "bufferarray.h"
 
 namespace LLWebProfileResponders
 {
@@ -54,11 +58,11 @@ public:
 	static void setImageUploadResultCallback(status_callback_t cb) { mStatusCallback = cb; }
 
 private:
-	friend class LLWebProfileResponders::ConfigResponder;
-	friend class LLWebProfileResponders::PostImageResponder;
-	friend class LLWebProfileResponders::PostImageRedirectResponder;
+    static LLCore::HttpHeaders::ptr_t buildDefaultHeaders();
+
+    static void uploadImageCoro(LLCoros::self& self, LLPointer<LLImageFormatted> image, std::string caption, bool add_location);
+    static LLCore::BufferArray::ptr_t buildPostData(const LLSD &data, LLPointer<LLImageFormatted> &image, const std::string &boundary);
 
-	static void post(LLPointer<LLImageFormatted> image, const LLSD& config, const std::string& url);
 	static void reportImageUploadStatus(bool ok);
 	static std::string getAuthCookie();
 
-- 
cgit v1.3


From 83543e556cba8753077c9f004bb0dc71b4509007 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 27 May 2015 17:15:01 -0700
Subject: Memory leak (extra ref) in webprofile Viewer media routines to
 coroutine. Post with raw respons in llcorehttputil LLCore::Http added headers
 only option (applies only on get)

---
 indra/llcorehttp/_httpoprequest.cpp |   8 +-
 indra/llcorehttp/httpoptions.cpp    |  29 ++-
 indra/llcorehttp/httpoptions.h      |  10 +
 indra/llmessage/llcorehttputil.cpp  |  12 +-
 indra/llmessage/llcorehttputil.h    |  13 +
 indra/newview/llviewermedia.cpp     | 483 ++++++++++++++++--------------------
 indra/newview/llviewermedia.h       |  14 +-
 indra/newview/llwebprofile.cpp      |   2 +-
 8 files changed, 282 insertions(+), 289 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/_httpoprequest.cpp b/indra/llcorehttp/_httpoprequest.cpp
index b1b05dc285..3b6647882e 100755
--- a/indra/llcorehttp/_httpoprequest.cpp
+++ b/indra/llcorehttp/_httpoprequest.cpp
@@ -532,6 +532,7 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 	long sslPeerV(0L);
 	long sslHostV(0L);
     long dnsCacheTimeout(-1L);
+    long nobody(0L);
 
 	if (mReqOptions)
 	{
@@ -539,6 +540,7 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 		sslPeerV = mReqOptions->getSSLVerifyPeer() ? 1L : 0L;
 		sslHostV = mReqOptions->getSSLVerifyHost() ? 2L : 0L;
 		dnsCacheTimeout = mReqOptions->getDNSCacheTimeout();
+        nobody = mReqOptions->getHeadersOnly() ? 1L : 0L;
 	}
 	code = curl_easy_setopt(mCurlHandle, CURLOPT_FOLLOWLOCATION, follow_redirect);
 	check_curl_easy_code(code, CURLOPT_FOLLOWLOCATION);
@@ -548,6 +550,9 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 	code = curl_easy_setopt(mCurlHandle, CURLOPT_SSL_VERIFYHOST, sslHostV);
 	check_curl_easy_code(code, CURLOPT_SSL_VERIFYHOST);
 
+    code = curl_easy_setopt(mCurlHandle, CURLOPT_NOBODY, nobody);
+    check_curl_easy_code(code, CURLOPT_NOBODY);
+
 	// The Linksys WRT54G V5 router has an issue with frequent
 	// DNS lookups from LAN machines.  If they happen too often,
 	// like for every HTTP request, the router gets annoyed after
@@ -587,7 +592,8 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 	switch (mReqMethod)
 	{
 	case HOR_GET:
-		code = curl_easy_setopt(mCurlHandle, CURLOPT_HTTPGET, 1);
+        if (nobody == 0)
+            code = curl_easy_setopt(mCurlHandle, CURLOPT_HTTPGET, 1);
 		check_curl_easy_code(code, CURLOPT_HTTPGET);
 		break;
 		
diff --git a/indra/llcorehttp/httpoptions.cpp b/indra/llcorehttp/httpoptions.cpp
index a4d08a80df..2b42bcaf6d 100755
--- a/indra/llcorehttp/httpoptions.cpp
+++ b/indra/llcorehttp/httpoptions.cpp
@@ -34,16 +34,17 @@ namespace LLCore
 
 
 HttpOptions::HttpOptions() : RefCounted(true),
-	mWantHeaders(false),
-	mTracing(HTTP_TRACE_OFF),
-	mTimeout(HTTP_REQUEST_TIMEOUT_DEFAULT),
-	mTransferTimeout(HTTP_REQUEST_XFER_TIMEOUT_DEFAULT),
-	mRetries(HTTP_RETRY_COUNT_DEFAULT),
-	mUseRetryAfter(HTTP_USE_RETRY_AFTER_DEFAULT),
-	mFollowRedirects(false),
-	mVerifyPeer(false),
-	mVerifyHost(false),
-    mDNSCacheTimeout(-1L)
+    mWantHeaders(false),
+    mTracing(HTTP_TRACE_OFF),
+    mTimeout(HTTP_REQUEST_TIMEOUT_DEFAULT),
+    mTransferTimeout(HTTP_REQUEST_XFER_TIMEOUT_DEFAULT),
+    mRetries(HTTP_RETRY_COUNT_DEFAULT),
+    mUseRetryAfter(HTTP_USE_RETRY_AFTER_DEFAULT),
+    mFollowRedirects(false),
+    mVerifyPeer(false),
+    mVerifyHost(false),
+    mDNSCacheTimeout(-1L),
+    mNoBody(false)
 {}
 
 
@@ -104,4 +105,12 @@ void HttpOptions::setDNSCacheTimeout(int timeout)
 {
 	mDNSCacheTimeout = timeout;
 }
+
+void HttpOptions::setHeadersOnly(bool nobody)
+{
+    mNoBody = nobody;
+    if (mNoBody)
+        setWantHeaders(true);
+}
+
 }   // end namespace LLCore
diff --git a/indra/llcorehttp/httpoptions.h b/indra/llcorehttp/httpoptions.h
index 765d2431bb..21ecff85af 100755
--- a/indra/llcorehttp/httpoptions.h
+++ b/indra/llcorehttp/httpoptions.h
@@ -149,6 +149,15 @@ public:
 	{
 		return mDNSCacheTimeout;
 	}
+
+    /// Retrieve only the headers and status from the request. Setting this 
+    /// to true implies setWantHeaders(true) as well.
+    /// Default: false
+    void                setHeadersOnly(bool nobody);
+    bool                getHeadersOnly() const
+    {
+        return mNoBody;
+    }
 	
 protected:
 	bool				mWantHeaders;
@@ -161,6 +170,7 @@ protected:
 	bool				mVerifyPeer;
 	bool        		mVerifyHost;
 	int					mDNSCacheTimeout;
+    bool                mNoBody;
 }; // end class HttpOptions
 
 
diff --git a/indra/llmessage/llcorehttputil.cpp b/indra/llmessage/llcorehttputil.cpp
index 001df9e385..c4a7e9040a 100644
--- a/indra/llmessage/llcorehttputil.cpp
+++ b/indra/llmessage/llcorehttputil.cpp
@@ -256,7 +256,7 @@ void HttpCoroHandler::onCompleted(LLCore::HttpHandle handle, LLCore::HttpRespons
 
     buildStatusEntry(response, status, result);
 
-#if 0
+#if 1
     // commenting out, but keeping since this can be useful for debugging
     if (!status)
     {
@@ -608,6 +608,16 @@ LLSD HttpCoroutineAdapter::postAndYield(LLCoros::self & self, LLCore::HttpReques
     return postAndYield_(self, request, url, rawbody, options, headers, httpHandler);
 }
 
+LLSD HttpCoroutineAdapter::postRawAndYield(LLCoros::self & self, 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 = HttpCoroHandler::ptr_t(new HttpCoroRawHandler(replyPump));
+
+    return postAndYield_(self, request, url, rawbody, options, headers, httpHandler);
+}
+
 LLSD HttpCoroutineAdapter::postAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
     const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
     LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index d6219318f9..213610e58e 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -334,6 +334,19 @@ public:
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
     }
 
+    LLSD postRawAndYield(LLCoros::self & self, 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(), false),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+
+    LLSD postRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
+        LLCore::HttpHeaders::ptr_t &headers)
+    {
+        return postRawAndYield(self, request, url, rawbody,
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
+    }
+
     /// Execute a Put transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available.
     /// 
diff --git a/indra/newview/llviewermedia.cpp b/indra/newview/llviewermedia.cpp
index 509227c683..02167b099e 100755
--- a/indra/newview/llviewermedia.cpp
+++ b/indra/newview/llviewermedia.cpp
@@ -69,6 +69,7 @@
 #include "llwebprofile.h"
 #include "llwindow.h"
 #include "llvieweraudio.h"
+#include "llcorehttputil.h"
 
 #include "llfloaterwebcontent.h"	// for handling window close requests and geometry change requests in media browser windows.
 
@@ -152,190 +153,6 @@ LLViewerMediaObserver::~LLViewerMediaObserver()
 }
 
 
-// Move this to its own file.
-// helper class that tries to download a URL from a web site and calls a method
-// on the Panel Land Media and to discover the MIME type
-class LLMimeDiscoveryResponder : public LLHTTPClient::Responder
-{
-	LOG_CLASS(LLMimeDiscoveryResponder);
-public:
-	LLMimeDiscoveryResponder( viewer_media_t media_impl)
-		: mMediaImpl(media_impl),
-		  mInitialized(false)
-	{
-		if(mMediaImpl->mMimeTypeProbe != NULL)
-		{
-			LL_ERRS() << "impl already has an outstanding responder" << LL_ENDL;
-		}
-		
-		mMediaImpl->mMimeTypeProbe = this;
-	}
-
-	~LLMimeDiscoveryResponder()
-	{
-		disconnectOwner();
-	}
-
-private:
-	/* virtual */ void httpCompleted()
-	{
-		if (!isGoodStatus())
-		{
-			LL_WARNS() << dumpResponse()
-					<< " [headers:" << getResponseHeaders() << "]" << LL_ENDL;
-		}
-		const std::string& media_type = getResponseHeader(HTTP_IN_HEADER_CONTENT_TYPE);
-		std::string::size_type idx1 = media_type.find_first_of(";");
-		std::string mime_type = media_type.substr(0, idx1);
-
-		LL_DEBUGS() << "status is " << getStatus() << ", media type \"" << media_type << "\"" << LL_ENDL;
-		
-		// 2xx status codes indicate success.
-		// Most 4xx status codes are successful enough for our purposes.
-		// 499 is the error code for host not found, timeout, etc.
-		// 500 means "Internal Server error" but we decided it's okay to 
-		//     accept this and go past it in the MIME type probe
-		// 302 means the resource can be found temporarily in a different place - added this for join.secondlife.com
-		// 499 is a code specifc to join.secondlife.com (?) apparently safe to ignore
-//		if(	((status >= 200) && (status < 300))	||
-//			((status >= 400) && (status < 499))	|| 
-//			(status == 500) ||
-//			(status == 302) ||
-//			(status == 499) 
-//			)
-		// We now no longer check the error code returned from the probe.
-		// If we have a mime type, use it.  If not, default to the web plugin and let it handle error reporting.
-		//if(1)
-		{
-			// The probe was successful.
-			if(mime_type.empty())
-			{
-				// Some sites don't return any content-type header at all.
-				// Treat an empty mime type as text/html.
-				mime_type = HTTP_CONTENT_TEXT_HTML;
-			}
-		}
-		//else
-		//{
-		//	LL_WARNS() << "responder failed with status " << dumpResponse() << LL_ENDL;
-		//
-		//	if(mMediaImpl)
-		//	{
-		//		mMediaImpl->mMediaSourceFailed = true;
-		//	}
-		//	return;
-		//}
-
-		// the call to initializeMedia may disconnect the responder, which will clear mMediaImpl.
-		// Make a local copy so we can call loadURI() afterwards.
-		LLViewerMediaImpl *impl = mMediaImpl;
-		
-		if(impl && !mInitialized && ! mime_type.empty())
-		{
-			if(impl->initializeMedia(mime_type))
-			{
-				mInitialized = true;
-				impl->loadURI();
-				disconnectOwner();
-			}
-		}
-	}
-	
-public:
-	void cancelRequest()
-	{
-		disconnectOwner();
-	}
-	
-private:
-	void disconnectOwner()
-	{
-		if(mMediaImpl)
-		{
-			if(mMediaImpl->mMimeTypeProbe != this)
-			{
-				LL_ERRS() << "internal error: mMediaImpl->mMimeTypeProbe != this" << LL_ENDL;
-			}
-
-			mMediaImpl->mMimeTypeProbe = NULL;
-		}
-		mMediaImpl = NULL;
-	}
-	
-	
-public:
-		LLViewerMediaImpl *mMediaImpl;
-		bool mInitialized;
-};
-
-class LLViewerMediaOpenIDResponder : public LLHTTPClient::Responder
-{
-	LOG_CLASS(LLViewerMediaOpenIDResponder);
-public:
-	LLViewerMediaOpenIDResponder( )
-	{
-	}
-
-	~LLViewerMediaOpenIDResponder()
-	{
-	}
-
-	/* virtual */ void completedRaw(
-		const LLChannelDescriptors& channels,
-		const LLIOPipe::buffer_ptr_t& buffer)
-	{
-		// We don't care about the content of the response, only the Set-Cookie header.
-		LL_DEBUGS("MediaAuth") << dumpResponse() 
-				<< " [headers:" << getResponseHeaders() << "]" << LL_ENDL;
-		const std::string& cookie = getResponseHeader(HTTP_IN_HEADER_SET_COOKIE);
-		
-		// *TODO: What about bad status codes?  Does this destroy previous cookies?
-		LLViewerMedia::openIDCookieResponse(cookie);
-	}
-
-};
-
-class LLViewerMediaWebProfileResponder : public LLHTTPClient::Responder
-{
-LOG_CLASS(LLViewerMediaWebProfileResponder);
-public:
-	LLViewerMediaWebProfileResponder(std::string host)
-	{
-		mHost = host;
-	}
-
-	~LLViewerMediaWebProfileResponder()
-	{
-	}
-
-	 void completedRaw(
-		const LLChannelDescriptors& channels,
-		const LLIOPipe::buffer_ptr_t& buffer)
-	{
-		// We don't care about the content of the response, only the set-cookie header.
-		LL_WARNS("MediaAuth") << dumpResponse() 
-				<< " [headers:" << getResponseHeaders() << "]" << LL_ENDL;
-
-		LLSD stripped_content = getResponseHeaders();
-		// *TODO: Check that this works.
-		stripped_content.erase(HTTP_IN_HEADER_SET_COOKIE);
-		LL_WARNS("MediaAuth") << stripped_content << LL_ENDL;
-
-		const std::string& cookie = getResponseHeader(HTTP_IN_HEADER_SET_COOKIE);
-		LL_DEBUGS("MediaAuth") << "cookie = " << cookie << LL_ENDL;
-
-		// *TODO: What about bad status codes?  Does this destroy previous cookies?
-		LLViewerMedia::getCookieStore()->setCookiesFromHost(cookie, mHost);
-
-		// Set cookie for snapshot publishing.
-		std::string auth_cookie = cookie.substr(0, cookie.find(";")); // strip path
-		LLWebProfile::setAuthCookie(auth_cookie);
-	}
-
-	std::string mHost;
-};
-
-
 LLPluginCookieStore *LLViewerMedia::sCookieStore = NULL;
 LLURL LLViewerMedia::sOpenIDURL;
 std::string LLViewerMedia::sOpenIDCookie;
@@ -1394,81 +1211,154 @@ void LLViewerMedia::setOpenIDCookie()
 {
 	if(!sOpenIDCookie.empty())
 	{
-		// The LLURL can give me the 'authority', which is of the form: [username[:password]@]hostname[:port]
-		// We want just the hostname for the cookie code, but LLURL doesn't seem to have a way to extract that.
-		// We therefore do it here.
-		std::string authority = sOpenIDURL.mAuthority;
-		std::string::size_type host_start = authority.find('@'); 
-		if(host_start == std::string::npos)
-		{
-			// no username/password
-			host_start = 0;
-		}
-		else
-		{
-			// Hostname starts after the @. 
-			// (If the hostname part is empty, this may put host_start at the end of the string.  In that case, it will end up passing through an empty hostname, which is correct.)
-			++host_start;
-		}
-		std::string::size_type host_end = authority.rfind(':'); 
-		if((host_end == std::string::npos) || (host_end < host_start))
-		{
-			// no port
-			host_end = authority.size();
-		}
-		
-		getCookieStore()->setCookiesFromHost(sOpenIDCookie, authority.substr(host_start, host_end - host_start));
+        std::string profileUrl = getProfileURL("");
+
+        LLCoros::instance().launch("LLViewerMedia::getOpenIDCookieCoro",
+            boost::bind(&LLViewerMedia::getOpenIDCookieCoro, _1, profileUrl));
+	}
+}
 
-		// Do a web profile get so we can store the cookie 
-		LLSD headers = LLSD::emptyMap();
-		headers[HTTP_OUT_HEADER_ACCEPT] = "*/*";
-		headers[HTTP_OUT_HEADER_COOKIE] = sOpenIDCookie;
-		headers[HTTP_OUT_HEADER_USER_AGENT] = getCurrentUserAgent();
+/*static*/
+void LLViewerMedia::getOpenIDCookieCoro(LLCoros::self& self, std::string url)
+{
+    LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
+    LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
+        httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("getOpenIDCookieCoro", httpPolicy));
+    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
+    LLCore::HttpHeaders::ptr_t httpHeaders(new LLCore::HttpHeaders);
+    
+    httpOpts->setFollowRedirects(true);
+    httpOpts->setWantHeaders(true);
+
+    LLURL hostUrl(url.c_str());
+    std::string hostAuth = hostUrl.getAuthority();
+
+    // *TODO: Expand LLURL to split and extract this information better. 
+    // The structure of a URL is well defined and needing to retrieve parts of it are common.
+    // original comment:
+    // The LLURL can give me the 'authority', which is of the form: [username[:password]@]hostname[:port]
+    // We want just the hostname for the cookie code, but LLURL doesn't seem to have a way to extract that.
+    // We therefore do it here.
+    std::string authority = sOpenIDURL.mAuthority;
+    std::string::size_type hostStart = authority.find('@');
+    if (hostStart == std::string::npos)
+    {   // no username/password
+        hostStart = 0;
+    }
+    else
+    {   // Hostname starts after the @. 
+        // (If the hostname part is empty, this may put host_start at the end of the string.  In that case, it will end up passing through an empty hostname, which is correct.)
+        ++hostStart;
+    }
+    std::string::size_type hostEnd = authority.rfind(':');
+    if ((hostEnd == std::string::npos) || (hostEnd < hostStart))
+    {   // no port
+        hostEnd = authority.size();
+    }
 
-		std::string profile_url = getProfileURL("");
-		LLURL raw_profile_url( profile_url.c_str() );
+    getCookieStore()->setCookiesFromHost(sOpenIDCookie, authority.substr(hostStart, hostEnd - hostStart));
+
+    // Do a web profile get so we can store the cookie 
+    httpHeaders->append(HTTP_OUT_HEADER_ACCEPT, "*/*");
+    httpHeaders->append(HTTP_OUT_HEADER_COOKIE, sOpenIDCookie);
+    httpHeaders->append(HTTP_OUT_HEADER_USER_AGENT, getCurrentUserAgent());
+
+
+    LL_DEBUGS("MediaAuth") << "Requesting " << url << LL_ENDL;
+    LL_DEBUGS("MediaAuth") << "sOpenIDCookie = [" << sOpenIDCookie << "]" << LL_ENDL;
+    
+    LLSD result = httpAdapter->getRawAndYield(self, httpRequest, url, httpOpts, httpHeaders);
+
+    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
+    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
+
+    if (!status)
+    {
+        LL_WARNS("MediaAuth") << "Error getting web profile." << LL_ENDL;
+        return;
+    }
+
+    LLSD resultHeaders = httpResults[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS_HEADERS];
+    if (!resultHeaders.has(HTTP_IN_HEADER_SET_COOKIE))
+    {
+        LL_WARNS("MediaAuth") << "No cookie in response." << LL_ENDL;
+        return;
+    }
+
+    const std::string& cookie = resultHeaders[HTTP_IN_HEADER_SET_COOKIE].asStringRef();
+    LL_DEBUGS("MediaAuth") << "cookie = " << cookie << LL_ENDL;
+
+    // *TODO: What about bad status codes?  Does this destroy previous cookies?
+    LLViewerMedia::getCookieStore()->setCookiesFromHost(cookie, hostAuth);
+
+    // Set cookie for snapshot publishing.
+    std::string authCookie = cookie.substr(0, cookie.find(";")); // strip path
+    LLWebProfile::setAuthCookie(authCookie);
 
-		LL_DEBUGS("MediaAuth") << "Requesting " << profile_url << LL_ENDL;
-		LL_DEBUGS("MediaAuth") << "sOpenIDCookie = [" << sOpenIDCookie << "]" << LL_ENDL;
-		LLHTTPClient::get(profile_url,  
-			new LLViewerMediaWebProfileResponder(raw_profile_url.getAuthority()),
-			headers);
-	}
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
 // static
-void LLViewerMedia::openIDSetup(const std::string &openid_url, const std::string &openid_token)
+void LLViewerMedia::openIDSetup(const std::string &openidUrl, const std::string &openidToken)
 {
-	LL_DEBUGS("MediaAuth") << "url = \"" << openid_url << "\", token = \"" << openid_token << "\"" << LL_ENDL;
+	LL_DEBUGS("MediaAuth") << "url = \"" << openidUrl << "\", token = \"" << openidToken << "\"" << LL_ENDL;
 
-	// post the token to the url 
-	// the responder will need to extract the cookie(s).
+    LLCoros::instance().launch("LLViewerMedia::openIDSetupCoro",
+        boost::bind(&LLViewerMedia::openIDSetupCoro, _1, openidUrl, openidToken));
+}
 
-	// Save the OpenID URL for later -- we may need the host when adding the cookie.
-	sOpenIDURL.init(openid_url.c_str());
-	
-	// We shouldn't ever do this twice, but just in case this code gets repurposed later, clear existing cookies.
-	sOpenIDCookie.clear();
+/*static*/
+void LLViewerMedia::openIDSetupCoro(LLCoros::self& self, std::string openidUrl, std::string openidToken)
+{
+    LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
+    LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
+        httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("openIDSetupCoro", httpPolicy));
+    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
+    LLCore::HttpHeaders::ptr_t httpHeaders(new LLCore::HttpHeaders);
 
-	LLSD headers = LLSD::emptyMap();
-	// Keep LLHTTPClient from adding an "Accept: application/llsd+xml" header
-	headers[HTTP_OUT_HEADER_ACCEPT] = "*/*";
-	// and use the expected content-type for a post, instead of the LLHTTPClient::postRaw() default of "application/octet-stream"
-	headers[HTTP_OUT_HEADER_CONTENT_TYPE] = "application/x-www-form-urlencoded";
-
-	// postRaw() takes ownership of the buffer and releases it later, so we need to allocate a new buffer here.
-	size_t size = openid_token.size();
-	U8 *data = new U8[size];
-	memcpy(data, openid_token.data(), size);
-
-	LLHTTPClient::postRaw( 
-		openid_url, 
-		data, 
-		size, 
-		new LLViewerMediaOpenIDResponder(),
-		headers);
-			
+    httpOpts->setWantHeaders(true);
+
+    // post the token to the url 
+    // the responder will need to extract the cookie(s).
+    // Save the OpenID URL for later -- we may need the host when adding the cookie.
+    sOpenIDURL.init(openidUrl.c_str());
+    // We shouldn't ever do this twice, but just in case this code gets repurposed later, clear existing cookies.
+    sOpenIDCookie.clear();
+
+    httpHeaders->append(HTTP_OUT_HEADER_ACCEPT, "*/*");
+    httpHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, "application/x-www-form-urlencoded");
+
+    LLCore::BufferArray::ptr_t rawbody(new LLCore::BufferArray, false);
+    LLCore::BufferArrayStream bas(rawbody.get());
+
+    bas << std::noskipws << openidToken;
+
+    LLSD result = httpAdapter->postRawAndYield(self, httpRequest, openidUrl, rawbody, httpOpts, httpHeaders);
+
+    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
+    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
+
+    if (!status)
+    {
+        LL_WARNS("MediaAuth") << "Error getting Open ID cookie" << LL_ENDL;
+        return;
+    }
+
+    LLSD resultHeaders = httpResults[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS_HEADERS];
+    if (!resultHeaders.has(HTTP_IN_HEADER_SET_COOKIE))
+    {
+        LL_WARNS("MediaAuth") << "No cookie in response." << LL_ENDL;
+        return;
+    }
+
+    // We don't care about the content of the response, only the Set-Cookie header.
+    const std::string &cookie = resultHeaders[HTTP_IN_HEADER_SET_COOKIE];
+
+    // *TODO: What about bad status codes?  Does this destroy previous cookies?
+    LLViewerMedia::openIDCookieResponse(cookie);
+    LL_DEBUGS("MediaAuth") << "OpenID cookie set." << LL_ENDL;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
@@ -1661,7 +1551,6 @@ LLViewerMediaImpl::LLViewerMediaImpl(	  const LLUUID& texture_id,
 	mIsParcelMedia(false),
 	mProximity(-1),
 	mProximityDistance(0.0f),
-	mMimeTypeProbe(NULL),
 	mMediaAutoPlay(false),
 	mInNearbyMediaList(false),
 	mClearCache(false),
@@ -1671,8 +1560,10 @@ LLViewerMediaImpl::LLViewerMediaImpl(	  const LLUUID& texture_id,
 	mIsUpdated(false),
 	mTrustedBrowser(false),
 	mZoomFactor(1.0),
-    mCleanBrowser(false)
-{ 
+    mCleanBrowser(false),
+    mMimeProbe(),
+    mCanceling(false)
+{
 
 	// Set up the mute list observer if it hasn't been set up already.
 	if(!sViewerMediaMuteListObserverInitialized)
@@ -2610,7 +2501,8 @@ void LLViewerMediaImpl::navigateInternal()
 		return;
 	}
 	
-	if(mMimeTypeProbe != NULL)
+    
+    if (!mMimeProbe.expired())
 	{
 		LL_WARNS() << "MIME type probe already in progress -- bailing out." << LL_ENDL;
 		return;
@@ -2648,14 +2540,8 @@ void LLViewerMediaImpl::navigateInternal()
 
 		if(scheme.empty() || "http" == scheme || "https" == scheme)
 		{
-			// If we don't set an Accept header, LLHTTPClient will add one like this:
-			//    Accept: application/llsd+xml
-			// which is really not what we want.
-			LLSD headers = LLSD::emptyMap();
-			headers[HTTP_OUT_HEADER_ACCEPT] = "*/*";
-			// Allow cookies in the response, to prevent a redirect loop when accessing join.secondlife.com
-			headers[HTTP_OUT_HEADER_COOKIE] = "";
-			LLHTTPClient::getHeaderOnly( mMediaURL, new LLMimeDiscoveryResponder(this), headers, 10.0f);
+            LLCoros::instance().launch("LLViewerMediaImpl::mimeDiscoveryCoro",
+                boost::bind(&LLViewerMediaImpl::mimeDiscoveryCoro, this, _1, mMediaURL));
 		}
 		else if("data" == scheme || "file" == scheme || "about" == scheme)
 		{
@@ -2685,6 +2571,65 @@ void LLViewerMediaImpl::navigateInternal()
 	}
 }
 
+void LLViewerMediaImpl::mimeDiscoveryCoro(LLCoros::self& self, std::string url)
+{
+    LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
+    LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
+        httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("mimeDiscoveryCoro", httpPolicy));
+    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
+    LLCore::HttpHeaders::ptr_t httpHeaders(new LLCore::HttpHeaders);
+
+    mMimeProbe = httpAdapter;
+
+    httpOpts->setHeadersOnly(true);
+
+    httpHeaders->append(HTTP_OUT_HEADER_ACCEPT, "*/*");
+    httpHeaders->append(HTTP_OUT_HEADER_COOKIE, "");
+
+    LLSD result = httpAdapter->getRawAndYield(self, httpRequest, url, httpOpts, httpHeaders);
+
+    mMimeProbe.reset();
+
+    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
+    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
+
+    if (!status)
+    {
+        LL_WARNS() << "Error retrieving media headers." << LL_ENDL;
+    }
+
+    LLSD resultHeaders = httpResults[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS_HEADERS];
+    
+    const std::string& mediaType = resultHeaders[HTTP_IN_HEADER_CONTENT_TYPE].asStringRef();
+
+    std::string::size_type idx1 = mediaType.find_first_of(";");
+    std::string mimeType = mediaType.substr(0, idx1);
+
+    // We now no longer need to check the error code returned from the probe.
+    // If we have a mime type, use it.  If not, default to the web plugin and let it handle error reporting.
+    // The probe was successful.
+    if (mimeType.empty())
+    {
+        // Some sites don't return any content-type header at all.
+        // Treat an empty mime type as text/html.
+        mimeType = HTTP_CONTENT_TEXT_HTML;
+    }
+
+    LL_DEBUGS() << "Media type \"" << mediaType << "\", mime type is \"" << mimeType << "\"" << LL_ENDL;
+
+    // the call to initializeMedia may disconnect the responder, which will clear mMediaImpl.
+    // Make a local copy so we can call loadURI() afterwards.
+
+    if (!mimeType.empty())
+    {
+        if (initializeMedia(mimeType))
+        {
+            loadURI();
+        }
+    }
+}
+
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::navigateStop()
 {
@@ -2783,7 +2728,7 @@ void LLViewerMediaImpl::update()
 		{
 			// Don't load new instances that are at PRIORITY_SLIDESHOW or below.  They're just kept around to preserve state.
 		}
-		else if(mMimeTypeProbe != NULL)
+        else if (!mMimeProbe.expired())
 		{
 			// this media source is doing a MIME type probe -- don't try loading it again.
 		}
@@ -3673,18 +3618,10 @@ void LLViewerMediaImpl::setNavigateSuspended(bool suspend)
 
 void LLViewerMediaImpl::cancelMimeTypeProbe()
 {
-	if(mMimeTypeProbe != NULL)
-	{
-		// There doesn't seem to be a way to actually cancel an outstanding request.
-		// Simulate it by telling the LLMimeDiscoveryResponder not to write back any results.
-		mMimeTypeProbe->cancelRequest();
-		
-		// The above should already have set mMimeTypeProbe to NULL.
-		if(mMimeTypeProbe != NULL)
-		{
-			LL_ERRS() << "internal error: mMimeTypeProbe is not NULL after cancelling request." << LL_ENDL;
-		}
-	}
+    LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t probeAdapter = mMimeProbe.lock();
+
+    if (probeAdapter)
+        probeAdapter->cancelYieldingOperation();
 }
 
 void LLViewerMediaImpl::addObject(LLVOVolume* obj) 
diff --git a/indra/newview/llviewermedia.h b/indra/newview/llviewermedia.h
index 6803adfaa2..5658651c6e 100755
--- a/indra/newview/llviewermedia.h
+++ b/indra/newview/llviewermedia.h
@@ -40,6 +40,9 @@
 #include "llnotificationptr.h"
 
 #include "llurl.h"
+#include "lleventcoro.h"
+#include "llcoros.h"
+#include "llcorehttputil.h"
 
 class LLViewerMediaImpl;
 class LLUUID;
@@ -165,7 +168,10 @@ public:
 private:
 	static void setOpenIDCookie();
 	static void onTeleportFinished();
-	
+
+    static void openIDSetupCoro(LLCoros::self& self, std::string openidUrl, std::string openidToken);
+    static void getOpenIDCookieCoro(LLCoros::self& self, std::string url);
+
 	static LLPluginCookieStore *sCookieStore;
 	static LLURL sOpenIDURL;
 	static std::string sOpenIDCookie;
@@ -180,7 +186,6 @@ class LLViewerMediaImpl
 public:
 	
 	friend class LLViewerMedia;
-	friend class LLMimeDiscoveryResponder;
 	
 	LLViewerMediaImpl(
 		const LLUUID& texture_id,
@@ -453,7 +458,6 @@ private:
 	S32 mProximity;
 	F64 mProximityDistance;
 	F64 mProximityCamera;
-	LLMimeDiscoveryResponder *mMimeTypeProbe;
 	bool mMediaAutoPlay;
 	std::string mMediaEntryURL;
 	bool mInNearbyMediaList;	// used by LLPanelNearbyMedia::refreshList() for performance reasons
@@ -470,6 +474,10 @@ private:
 	BOOL mIsUpdated ;
 	std::list< LLVOVolume* > mObjectList ;
 
+    void mimeDiscoveryCoro(LLCoros::self& self, std::string url);
+    LLCoreHttpUtil::HttpCoroutineAdapter::wptr_t mMimeProbe;
+    bool mCanceling;
+
 private:
 	LLViewerMediaTexture *updatePlaceholderImage();
 };
diff --git a/indra/newview/llwebprofile.cpp b/indra/newview/llwebprofile.cpp
index df5f4e3588..a72deafe33 100755
--- a/indra/newview/llwebprofile.cpp
+++ b/indra/newview/llwebprofile.cpp
@@ -202,7 +202,7 @@ void LLWebProfile::uploadImageCoro(LLCoros::self& self, LLPointer<LLImageFormatt
 /*static*/
 LLCore::BufferArray::ptr_t LLWebProfile::buildPostData(const LLSD &data, LLPointer<LLImageFormatted> &image, const std::string &boundary)
 {
-    LLCore::BufferArray::ptr_t body(new LLCore::BufferArray);
+    LLCore::BufferArray::ptr_t body(new LLCore::BufferArray, false);
     LLCore::BufferArrayStream bas(body.get());
 
     // *NOTE: The order seems to matter.
-- 
cgit v1.3


From 68da6fa846fee1e3c5fb478945ef54f83a86aacd Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Mon, 1 Jun 2015 16:54:53 -0700
Subject: Set follow redirects so that the default is the same when no options
 are are specified and when follow redirects is not specified on the options
 object.

---
 indra/llcorehttp/httpoptions.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/httpoptions.cpp b/indra/llcorehttp/httpoptions.cpp
index 2b42bcaf6d..3459a37aff 100755
--- a/indra/llcorehttp/httpoptions.cpp
+++ b/indra/llcorehttp/httpoptions.cpp
@@ -40,7 +40,7 @@ HttpOptions::HttpOptions() : RefCounted(true),
     mTransferTimeout(HTTP_REQUEST_XFER_TIMEOUT_DEFAULT),
     mRetries(HTTP_RETRY_COUNT_DEFAULT),
     mUseRetryAfter(HTTP_USE_RETRY_AFTER_DEFAULT),
-    mFollowRedirects(false),
+    mFollowRedirects(true),
     mVerifyPeer(false),
     mVerifyHost(false),
     mDNSCacheTimeout(-1L),
-- 
cgit v1.3


From daf4d167b66c6124b96dee585b43060e2ea06b42 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Fri, 5 Jun 2015 15:19:24 -0700
Subject: Added a seek method to LLCore::Http for data rewind. A couple of
 minor changes to merchant out box in hopes that the would fix the issues.

---
 indra/llcorehttp/_httpoprequest.cpp      | 35 ++++++++++++++++++++++++++++++++
 indra/llcorehttp/_httpoprequest.h        |  1 +
 indra/newview/llmarketplacefunctions.cpp |  6 +++---
 3 files changed, 39 insertions(+), 3 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/_httpoprequest.cpp b/indra/llcorehttp/_httpoprequest.cpp
index 3b6647882e..3a51f898ab 100755
--- a/indra/llcorehttp/_httpoprequest.cpp
+++ b/indra/llcorehttp/_httpoprequest.cpp
@@ -515,6 +515,10 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 	check_curl_easy_code(code, CURLOPT_READFUNCTION);
 	code = curl_easy_setopt(mCurlHandle, CURLOPT_READDATA, this);
 	check_curl_easy_code(code, CURLOPT_READDATA);
+    code = curl_easy_setopt(mCurlHandle, CURLOPT_SEEKFUNCTION, seekCallback);
+    check_curl_easy_code(code, CURLOPT_SEEKFUNCTION);
+    code = curl_easy_setopt(mCurlHandle, CURLOPT_SEEKDATA, this);
+    check_curl_easy_code(code, CURLOPT_SEEKDATA);
 
 	code = curl_easy_setopt(mCurlHandle, CURLOPT_COOKIEFILE, "");
 	check_curl_easy_code(code, CURLOPT_COOKIEFILE);
@@ -819,6 +823,37 @@ size_t HttpOpRequest::readCallback(void * data, size_t size, size_t nmemb, void
 	return read_size;
 }
 
+
+int HttpOpRequest::seekCallback(void *userdata, curl_off_t offset, int origin)
+{
+    HttpOpRequest * op(static_cast<HttpOpRequest *>(userdata));
+
+    if (!op->mReqBody)
+    {
+        return 0;
+    }
+
+    size_t newPos = 0;
+    if (origin == SEEK_SET)
+        newPos = offset;
+    else if (origin == SEEK_END)
+        newPos = static_cast<curl_off_t>(op->mReqBody->size()) + offset;
+    else if (origin == SEEK_CUR)
+        newPos = static_cast<curl_off_t>(op->mCurlBodyPos) + offset;
+    else
+        return 2;
+
+    if ((newPos < 0) || (newPos >= op->mReqBody->size()))
+    {
+        LL_WARNS(LOG_CORE) << "Attempt to seek to position outside post body." << LL_ENDL;
+        return 2;
+    }
+
+    op->mCurlBodyPos = (size_t)newPos;
+
+    return 0;
+}
+
 		
 size_t HttpOpRequest::headerCallback(void * data, size_t size, size_t nmemb, void * userdata)
 {
diff --git a/indra/llcorehttp/_httpoprequest.h b/indra/llcorehttp/_httpoprequest.h
index ca40898a81..b1bb101bea 100755
--- a/indra/llcorehttp/_httpoprequest.h
+++ b/indra/llcorehttp/_httpoprequest.h
@@ -175,6 +175,7 @@ protected:
 	//
 	static size_t writeCallback(void * data, size_t size, size_t nmemb, void * userdata);
 	static size_t readCallback(void * data, size_t size, size_t nmemb, void * userdata);
+    static int seekCallback(void *data, curl_off_t offset, int origin);
 	static size_t headerCallback(void * data, size_t size, size_t nmemb, void * userdata);
 	static CURLcode curlSslCtxCallback(CURL *curl, void *ssl_ctx, void *userptr);
 	static int sslCertVerifyCallback(X509_STORE_CTX *ctx, void *param);
diff --git a/indra/newview/llmarketplacefunctions.cpp b/indra/newview/llmarketplacefunctions.cpp
index d095623b2e..bd77912a6c 100755
--- a/indra/newview/llmarketplacefunctions.cpp
+++ b/indra/newview/llmarketplacefunctions.cpp
@@ -136,7 +136,7 @@ namespace LLMarketplaceImport
         LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
         httpOpts->setWantHeaders(true);
-        httpOpts->setFollowRedirects(false);
+        httpOpts->setFollowRedirects(true);
 
         httpHeaders->append(HTTP_OUT_HEADER_ACCEPT, "*/*");
         httpHeaders->append(HTTP_OUT_HEADER_CONNECTION, "Keep-Alive");
@@ -241,13 +241,13 @@ namespace LLMarketplaceImport
     {
         LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
         LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
-            httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("marketplacePostCoro", httpPolicy));
+            httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("marketplaceGetCoro", httpPolicy));
         LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
         LLCore::HttpHeaders::ptr_t httpHeaders; 
         LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
         httpOpts->setWantHeaders(true);
-        httpOpts->setFollowRedirects(false);
+        httpOpts->setFollowRedirects(!sMarketplaceCookie.empty());
 
         if (buildHeaders)
         {
-- 
cgit v1.3


From dde75d76210c9e4df0516b89f8f199fe081a5e87 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Fri, 5 Jun 2015 16:11:27 -0700
Subject: Mac builds are very picking about testing an unsigned for < 0

---
 indra/llcorehttp/_httpoprequest.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/_httpoprequest.cpp b/indra/llcorehttp/_httpoprequest.cpp
index 3a51f898ab..503c04dfa7 100755
--- a/indra/llcorehttp/_httpoprequest.cpp
+++ b/indra/llcorehttp/_httpoprequest.cpp
@@ -843,7 +843,7 @@ int HttpOpRequest::seekCallback(void *userdata, curl_off_t offset, int origin)
     else
         return 2;
 
-    if ((newPos < 0) || (newPos >= op->mReqBody->size()))
+    if (newPos >= op->mReqBody->size())
     {
         LL_WARNS(LOG_CORE) << "Attempt to seek to position outside post body." << LL_ENDL;
         return 2;
-- 
cgit v1.3


From 97033975510d0514821f943287d91708eefa9c92 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 24 Jun 2015 10:10:22 -0700
Subject: MAINT-5295 Remove POSTFIELDS from PUT operation.

---
 indra/llcorehttp/_httpoprequest.cpp | 2 --
 1 file changed, 2 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/_httpoprequest.cpp b/indra/llcorehttp/_httpoprequest.cpp
index 503c04dfa7..799587ff22 100755
--- a/indra/llcorehttp/_httpoprequest.cpp
+++ b/indra/llcorehttp/_httpoprequest.cpp
@@ -635,8 +635,6 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 			}
 			code = curl_easy_setopt(mCurlHandle, CURLOPT_INFILESIZE, data_size);
 			check_curl_easy_code(code, CURLOPT_INFILESIZE);
-			code = curl_easy_setopt(mCurlHandle, CURLOPT_POSTFIELDS, (void *) NULL);
-			check_curl_easy_code(code, CURLOPT_POSTFIELDS);
 			mCurlHeaders = curl_slist_append(mCurlHeaders, "Expect:");
 		}
 		break;
-- 
cgit v1.3


From 76cb1fcf0b5b9d8415e2517c482bab0c6c6602fb Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 29 Jun 2015 15:37:32 -0400
Subject: MAINT-4952: Add IntrusivePtr wrapper for boost::intrusive_ptr. For a
 RefCounted subclass T, boost::intrusive_ptr<T> must be instantiated as
 boost::intrusive_ptr<T>(raw ptr, false) to avoid immortal instances.
 Forgetting that final bool parameter is both easy and extremely hard to spot
 with desk checking or code review. IntrusivePtr<T> provides constructors that
 Do The Right Thing, so we can typedef a subclass T's ptr_t to IntrusivePtr<T>
 rather than directly to boost::intrusive_ptr<T>.

---
 indra/llcorehttp/_refcounted.h | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/_refcounted.h b/indra/llcorehttp/_refcounted.h
index cd16e2e2b4..7f713f2298 100755
--- a/indra/llcorehttp/_refcounted.h
+++ b/indra/llcorehttp/_refcounted.h
@@ -32,6 +32,7 @@
 
 #include "fix_macros.h"
 #include <boost/thread.hpp>
+#include <boost/intrusive_ptr.hpp>
 
 #include "llapr.h"
 
@@ -120,6 +121,24 @@ inline void RefCounted::destroySelf()
 	delete this;
 }
 
+/**
+ * boost::intrusive_ptr may be used to manage RefCounted classes.
+ * Unfortunately RefCounted and boost::intrusive_ptr use different conventions
+ * for the initial refcount value. To avoid leaky (immortal) objects, you
+ * should really construct boost::intrusive_ptr<RefCounted*>(rawptr, false).
+ * IntrusivePtr<T> encapsulates that for you.
+ */
+template <typename T>
+struct IntrusivePtr: public boost::intrusive_ptr<T>
+{
+	IntrusivePtr():
+		boost::intrusive_ptr<T>()
+	{}
+	IntrusivePtr(T* p):
+		boost::intrusive_ptr<T>(p, false)
+	{}
+};
+
 inline void intrusive_ptr_add_ref(RefCounted* p)
 {
 	p->addRef();
-- 
cgit v1.3


From 80d17b2dd9cdd7a9445480fdb0e12774396751eb Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 29 Jun 2015 17:19:51 -0400
Subject: MAINT-4952: Use IntrusivePtr for BufferArray,HttpHeaders,HttpOptions.
 Specifically, change the ptr_t typedefs for these LLCore classes to use
 IntrusivePtr rather than directly using boost::intrusive_ptr. This allows us
 to use a simple ptr_t(raw ptr) constructor rather than having to remember to
 code ptr_t(raw ptr, false) everywhere. In fact, the latter form is now
 invalid: remove the now-extraneous 'false' constructor parameters.

---
 indra/llcorehttp/bufferarray.h        |  2 +-
 indra/llcorehttp/httpheaders.h        |  2 +-
 indra/llcorehttp/httpoptions.h        |  2 +-
 indra/llcrashlogger/llcrashlogger.cpp |  2 +-
 indra/llmessage/llavatarnamecache.cpp |  4 +--
 indra/llmessage/llcorehttputil.cpp    |  8 ++---
 indra/llmessage/llcorehttputil.h      | 56 +++++++++++++++++------------------
 indra/newview/llfacebookconnect.cpp   | 18 +++++------
 indra/newview/llflickrconnect.cpp     | 16 +++++-----
 indra/newview/llgroupmgr.cpp          |  4 +--
 indra/newview/llmaterialmgr.cpp       |  4 +--
 indra/newview/llmediadataclient.cpp   |  4 +--
 indra/newview/lltwitterconnect.cpp    | 16 +++++-----
 indra/newview/llviewermedia.cpp       |  2 +-
 indra/newview/llwebprofile.cpp        |  2 +-
 indra/newview/llxmlrpctransaction.cpp |  6 ++--
 16 files changed, 74 insertions(+), 74 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/bufferarray.h b/indra/llcorehttp/bufferarray.h
index 076f341736..320adf2b8b 100755
--- a/indra/llcorehttp/bufferarray.h
+++ b/indra/llcorehttp/bufferarray.h
@@ -74,7 +74,7 @@ public:
 	
 	BufferArray();
 
-	typedef boost::intrusive_ptr<BufferArray> ptr_t;
+	typedef LLCoreInt::IntrusivePtr<BufferArray> ptr_t;
 
 protected:
 	virtual ~BufferArray();						// Use release()
diff --git a/indra/llcorehttp/httpheaders.h b/indra/llcorehttp/httpheaders.h
index 51bd76a01d..8f14568fa3 100755
--- a/indra/llcorehttp/httpheaders.h
+++ b/indra/llcorehttp/httpheaders.h
@@ -92,7 +92,7 @@ public:
 	/// the instance.
 	HttpHeaders();
 
-	typedef boost::intrusive_ptr<HttpHeaders> ptr_t;
+	typedef LLCoreInt::IntrusivePtr<HttpHeaders> ptr_t;
 protected:
 	virtual ~HttpHeaders();						// Use release()
 
diff --git a/indra/llcorehttp/httpoptions.h b/indra/llcorehttp/httpoptions.h
index 21ecff85af..2fe05a65ff 100755
--- a/indra/llcorehttp/httpoptions.h
+++ b/indra/llcorehttp/httpoptions.h
@@ -60,7 +60,7 @@ class HttpOptions : public LLCoreInt::RefCounted
 public:
 	HttpOptions();
 
-	typedef boost::intrusive_ptr<HttpOptions> ptr_t;
+	typedef LLCoreInt::IntrusivePtr<HttpOptions> ptr_t;
 
 protected:
 	virtual ~HttpOptions();						// Use release()
diff --git a/indra/llcrashlogger/llcrashlogger.cpp b/indra/llcrashlogger/llcrashlogger.cpp
index 90f70c0d1c..cb05c4ff03 100755
--- a/indra/llcrashlogger/llcrashlogger.cpp
+++ b/indra/llcrashlogger/llcrashlogger.cpp
@@ -397,7 +397,7 @@ bool LLCrashLogger::saveCrashBehaviorSetting(S32 crash_behavior)
 bool LLCrashLogger::runCrashLogPost(std::string host, LLSD data, std::string msg, int retries, int timeout)
 {
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
 	gBreak = false;
     httpOpts->setTimeout(timeout);
diff --git a/indra/llmessage/llavatarnamecache.cpp b/indra/llmessage/llavatarnamecache.cpp
index e4b8642c4d..7014048021 100755
--- a/indra/llmessage/llavatarnamecache.cpp
+++ b/indra/llmessage/llavatarnamecache.cpp
@@ -468,8 +468,8 @@ void LLAvatarNameCache::initClass(bool running, bool usePeopleAPI)
 	sUsePeopleAPI = usePeopleAPI;
 
     sHttpRequest = LLCore::HttpRequest::ptr_t(new LLCore::HttpRequest());
-    sHttpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false);
-    sHttpOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false);
+    sHttpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders());
+    sHttpOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions());
     sHttpPolicy = LLCore::HttpRequest::DEFAULT_POLICY_ID;
     sHttpPriority = 0;
 }
diff --git a/indra/llmessage/llcorehttputil.cpp b/indra/llmessage/llcorehttputil.cpp
index 68c55eaf54..4ec01aa405 100644
--- a/indra/llmessage/llcorehttputil.cpp
+++ b/indra/llmessage/llcorehttputil.cpp
@@ -628,7 +628,7 @@ LLSD HttpCoroutineAdapter::postFileAndYield(LLCoros::self & self, LLCore::HttpRe
     const std::string & url, std::string fileName,
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
-    LLCore::BufferArray::ptr_t fileData(new LLCore::BufferArray, false);
+    LLCore::BufferArray::ptr_t fileData(new LLCore::BufferArray);
 
     // scoping for our streams so that they go away when we no longer need them.
     {
@@ -657,7 +657,7 @@ LLSD HttpCoroutineAdapter::postFileAndYield(LLCoros::self & self, LLCore::HttpRe
     const std::string & url, LLUUID assetId, LLAssetType::EType assetType,
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
-    LLCore::BufferArray::ptr_t fileData(new LLCore::BufferArray, false);
+    LLCore::BufferArray::ptr_t fileData(new LLCore::BufferArray);
 
     // scoping for our streams so that they go away when we no longer need them.
     {
@@ -926,7 +926,7 @@ void HttpCoroutineAdapter::trivialGetCoro(LLCoros::self& self, std::string url,
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("genericGetCoro", policyId));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     httpOpts->setWantHeaders(true);
 
@@ -977,7 +977,7 @@ void HttpCoroutineAdapter::trivialPostCoro(LLCoros::self& self, std::string url,
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("genericPostCoro", policyId));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     httpOpts->setWantHeaders(true);
 
diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 17168bd1f8..7dd161d1cd 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -322,18 +322,18 @@ public:
     /// not be deallocated during the yield.
     LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        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(LLCoros::self & self, 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(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        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(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpHeaders::ptr_t &headers)
     {
         return postAndYield(self, request, url, body,
-            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
     LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
@@ -341,47 +341,47 @@ public:
         LLCore::HttpHeaders::ptr_t &headers)
     {
         return postAndYield(self, request, url, rawbody,
-            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
     LLSD postRawAndYield(LLCoros::self & self, 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(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        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(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
         LLCore::HttpHeaders::ptr_t &headers)
     {
         return postRawAndYield(self, request, url, rawbody,
-            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
     LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, std::string fileName,
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        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(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, std::string fileName,
         LLCore::HttpHeaders::ptr_t &headers)
     {
         return postFileAndYield(self, request, url, fileName,
-            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
 
     LLSD postFileAndYield(LLCoros::self & self, 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(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        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(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLUUID assetId, LLAssetType::EType assetType,
         LLCore::HttpHeaders::ptr_t &headers)
     {
         return postFileAndYield(self, request, url, assetId, assetType,
-            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
 
@@ -392,8 +392,8 @@ public:
     /// not be deallocated during the yield.
     LLSD putAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
     /// Execute a Get transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available.
@@ -402,37 +402,37 @@ public:
     /// not be deallocated during the yield.
     LLSD getAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url,
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        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(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
         return getAndYield(self, request, url,
-            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
 
     LLSD getRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url,
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        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(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
         return getRawAndYield(self, request, url,
-            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
 
     LLSD getJsonAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url,
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        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 getJsonndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
         return getJsonAndYield(self, request, url,
-            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
 
@@ -444,8 +444,8 @@ public:
     /// not be deallocated during the yield.
     LLSD deleteAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url,
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
     ///
     void cancelYieldingOperation();
diff --git a/indra/newview/llfacebookconnect.cpp b/indra/newview/llfacebookconnect.cpp
index 29c5d0c673..a1700a4357 100755
--- a/indra/newview/llfacebookconnect.cpp
+++ b/indra/newview/llfacebookconnect.cpp
@@ -131,7 +131,7 @@ void LLFacebookConnect::facebookConnectCoro(LLCoros::self& self, std::string aut
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("FacebookConnect", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     LLSD putData;
     if (!authCode.empty())
@@ -218,7 +218,7 @@ void LLFacebookConnect::facebookShareCoro(LLCoros::self& self, std::string route
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("FacebookConnect", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     httpOpts->setWantHeaders(true);
     httpOpts->setFollowRedirects(false);
@@ -241,8 +241,8 @@ void LLFacebookConnect::facebookShareImageCoro(LLCoros::self& self, std::string
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("FacebookConnect", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpHeaders::ptr_t httpHeaders(new LLCore::HttpHeaders, false);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpHeaders::ptr_t httpHeaders(new LLCore::HttpHeaders);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     httpOpts->setWantHeaders(true);
     httpOpts->setFollowRedirects(false);
@@ -268,7 +268,7 @@ void LLFacebookConnect::facebookShareImageCoro(LLCoros::self& self, std::string
     std::string contentType = "multipart/form-data; boundary=" + boundary;
     httpHeaders->append("Content-Type", contentType.c_str());
 
-    LLCore::BufferArray::ptr_t raw = LLCore::BufferArray::ptr_t(new LLCore::BufferArray(), false); // 
+    LLCore::BufferArray::ptr_t raw = LLCore::BufferArray::ptr_t(new LLCore::BufferArray()); // 
     LLCore::BufferArrayStream body(raw.get());
 
     // *NOTE: The order seems to matter.
@@ -310,7 +310,7 @@ void LLFacebookConnect::facebookDisconnectCoro(LLCoros::self& self)
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("FacebookConnect", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     setConnectionState(LLFacebookConnect::FB_DISCONNECTING);
     httpOpts->setFollowRedirects(false);
@@ -345,7 +345,7 @@ void LLFacebookConnect::facebookConnectedCheckCoro(LLCoros::self& self, bool aut
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("FacebookConnect", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     setConnectionState(LLFacebookConnect::FB_CONNECTION_IN_PROGRESS);
 
@@ -394,7 +394,7 @@ void LLFacebookConnect::facebookConnectInfoCoro(LLCoros::self& self)
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("FacebookConnect", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     httpOpts->setWantHeaders(true);
     httpOpts->setFollowRedirects(false);
@@ -438,7 +438,7 @@ void LLFacebookConnect::facebookConnectFriendsCoro(LLCoros::self& self)
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("FacebookConnect", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     httpOpts->setFollowRedirects(false);
 
diff --git a/indra/newview/llflickrconnect.cpp b/indra/newview/llflickrconnect.cpp
index 570b93c33c..873b1a7138 100644
--- a/indra/newview/llflickrconnect.cpp
+++ b/indra/newview/llflickrconnect.cpp
@@ -73,7 +73,7 @@ void LLFlickrConnect::flickrConnectCoro(LLCoros::self& self, std::string request
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("FlickrConnect", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     httpOpts->setWantHeaders(true);
     httpOpts->setFollowRedirects(false);
@@ -163,7 +163,7 @@ void LLFlickrConnect::flickrShareCoro(LLCoros::self& self, LLSD share)
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("FlickrConnect", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     httpOpts->setWantHeaders(true);
     httpOpts->setFollowRedirects(false);
@@ -187,8 +187,8 @@ void LLFlickrConnect::flickrShareImageCoro(LLCoros::self& self, LLPointer<LLImag
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("FlickrConnect", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpHeaders::ptr_t httpHeaders(new LLCore::HttpHeaders, false);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpHeaders::ptr_t httpHeaders(new LLCore::HttpHeaders);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     httpOpts->setWantHeaders(true);
     httpOpts->setFollowRedirects(false);
@@ -214,7 +214,7 @@ void LLFlickrConnect::flickrShareImageCoro(LLCoros::self& self, LLPointer<LLImag
     std::string contentType = "multipart/form-data; boundary=" + boundary;
     httpHeaders->append("Content-Type", contentType.c_str());
 
-    LLCore::BufferArray::ptr_t raw = LLCore::BufferArray::ptr_t(new LLCore::BufferArray(), false); // 
+    LLCore::BufferArray::ptr_t raw = LLCore::BufferArray::ptr_t(new LLCore::BufferArray()); // 
     LLCore::BufferArrayStream body(raw.get());
 
     // *NOTE: The order seems to matter.
@@ -266,7 +266,7 @@ void LLFlickrConnect::flickrDisconnectCoro(LLCoros::self& self)
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("FlickrConnect", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     setConnectionState(LLFlickrConnect::FLICKR_DISCONNECTING);
     httpOpts->setFollowRedirects(false);
@@ -300,7 +300,7 @@ void LLFlickrConnect::flickrConnectedCoro(LLCoros::self& self, bool autoConnect)
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("FlickrConnect", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     setConnectionState(LLFlickrConnect::FLICKR_CONNECTION_IN_PROGRESS);
 
@@ -350,7 +350,7 @@ void LLFlickrConnect::flickrInfoCoro(LLCoros::self& self)
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("FlickrConnect", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     httpOpts->setWantHeaders(true);
     httpOpts->setFollowRedirects(false);
diff --git a/indra/newview/llgroupmgr.cpp b/indra/newview/llgroupmgr.cpp
index 0852104ba7..0fb39ab02e 100755
--- a/indra/newview/llgroupmgr.cpp
+++ b/indra/newview/llgroupmgr.cpp
@@ -1897,8 +1897,8 @@ void LLGroupMgr::postGroupBanRequestCoro(LLCoros::self& self, std::string url, L
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("groupMembersRequest", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpHeaders::ptr_t httpHeaders(new LLCore::HttpHeaders, false);
-    LLCore::HttpOptions::ptr_t httpOptions(new LLCore::HttpOptions, false);
+    LLCore::HttpHeaders::ptr_t httpHeaders(new LLCore::HttpHeaders);
+    LLCore::HttpOptions::ptr_t httpOptions(new LLCore::HttpOptions);
 
     httpOptions->setFollowRedirects(false);
 
diff --git a/indra/newview/llmaterialmgr.cpp b/indra/newview/llmaterialmgr.cpp
index 8a726ec7c9..aef5bcf0dd 100755
--- a/indra/newview/llmaterialmgr.cpp
+++ b/indra/newview/llmaterialmgr.cpp
@@ -139,8 +139,8 @@ LLMaterialMgr::LLMaterialMgr():
 	LLAppCoreHttp & app_core_http(LLAppViewer::instance()->getAppCoreHttp());
 
 	mHttpRequest = LLCore::HttpRequest::ptr_t(new LLCore::HttpRequest());
-	mHttpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false);
-	mHttpOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false);
+	mHttpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders());
+	mHttpOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions());
 	mHttpPolicy = app_core_http.getPolicy(LLAppCoreHttp::AP_MATERIALS);
 
 	mMaterials.insert(std::pair<LLMaterialID, LLMaterialPtr>(LLMaterialID::null, LLMaterialPtr(NULL)));
diff --git a/indra/newview/llmediadataclient.cpp b/indra/newview/llmediadataclient.cpp
index f996e7b26e..b8ff76aa6d 100755
--- a/indra/newview/llmediadataclient.cpp
+++ b/indra/newview/llmediadataclient.cpp
@@ -178,8 +178,8 @@ LLMediaDataClient::LLMediaDataClient(F32 queue_timer_delay, F32 retry_timer_dela
     mMaxRoundRobinQueueSize(max_round_robin_queue_size),
     mQueueTimerIsRunning(false),
     mHttpRequest(new LLCore::HttpRequest()),
-    mHttpHeaders(new LLCore::HttpHeaders(), false),
-    mHttpOpts(new LLCore::HttpOptions(), false),
+    mHttpHeaders(new LLCore::HttpHeaders()),
+    mHttpOpts(new LLCore::HttpOptions()),
     mHttpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID)
 {
     // *TODO: Look up real Policy ID
diff --git a/indra/newview/lltwitterconnect.cpp b/indra/newview/lltwitterconnect.cpp
index 3ad7a58bdc..09435850c3 100644
--- a/indra/newview/lltwitterconnect.cpp
+++ b/indra/newview/lltwitterconnect.cpp
@@ -73,7 +73,7 @@ void LLTwitterConnect::twitterConnectCoro(LLCoros::self& self, std::string reque
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("TwitterConnect", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     httpOpts->setWantHeaders(true);
     httpOpts->setFollowRedirects(false);
@@ -163,7 +163,7 @@ void LLTwitterConnect::twitterShareCoro(LLCoros::self& self, std::string route,
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("TwitterConnect", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     httpOpts->setWantHeaders(true);
     httpOpts->setFollowRedirects(false);
@@ -186,8 +186,8 @@ void LLTwitterConnect::twitterShareImageCoro(LLCoros::self& self, LLPointer<LLIm
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("FlickrConnect", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpHeaders::ptr_t httpHeaders(new LLCore::HttpHeaders, false);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpHeaders::ptr_t httpHeaders(new LLCore::HttpHeaders);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     httpOpts->setWantHeaders(true);
     httpOpts->setFollowRedirects(false);
@@ -213,7 +213,7 @@ void LLTwitterConnect::twitterShareImageCoro(LLCoros::self& self, LLPointer<LLIm
     std::string contentType = "multipart/form-data; boundary=" + boundary;
     httpHeaders->append("Content-Type", contentType.c_str());
 
-    LLCore::BufferArray::ptr_t raw = LLCore::BufferArray::ptr_t(new LLCore::BufferArray(), false); // 
+    LLCore::BufferArray::ptr_t raw = LLCore::BufferArray::ptr_t(new LLCore::BufferArray()); // 
     LLCore::BufferArrayStream body(raw.get());
 
     // *NOTE: The order seems to matter.
@@ -253,7 +253,7 @@ void LLTwitterConnect::twitterDisconnectCoro(LLCoros::self& self)
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("TwitterConnect", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     httpOpts->setFollowRedirects(false);
 
@@ -288,7 +288,7 @@ void LLTwitterConnect::twitterConnectedCoro(LLCoros::self& self, bool autoConnec
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("TwitterConnect", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     httpOpts->setFollowRedirects(false);
     setConnectionState(LLTwitterConnect::TWITTER_CONNECTION_IN_PROGRESS);
@@ -337,7 +337,7 @@ void LLTwitterConnect::twitterInfoCoro(LLCoros::self& self)
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("TwitterConnect", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions, false);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     httpOpts->setWantHeaders(true);
     httpOpts->setFollowRedirects(false);
diff --git a/indra/newview/llviewermedia.cpp b/indra/newview/llviewermedia.cpp
index 6784c97192..6d0fce46aa 100755
--- a/indra/newview/llviewermedia.cpp
+++ b/indra/newview/llviewermedia.cpp
@@ -1342,7 +1342,7 @@ void LLViewerMedia::openIDSetupCoro(LLCoros::self& self, std::string openidUrl,
     httpHeaders->append(HTTP_OUT_HEADER_ACCEPT, "*/*");
     httpHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, "application/x-www-form-urlencoded");
 
-    LLCore::BufferArray::ptr_t rawbody(new LLCore::BufferArray, false);
+    LLCore::BufferArray::ptr_t rawbody(new LLCore::BufferArray);
     LLCore::BufferArrayStream bas(rawbody.get());
 
     bas << std::noskipws << openidToken;
diff --git a/indra/newview/llwebprofile.cpp b/indra/newview/llwebprofile.cpp
index 727c9ffb18..62ba40ca32 100755
--- a/indra/newview/llwebprofile.cpp
+++ b/indra/newview/llwebprofile.cpp
@@ -202,7 +202,7 @@ void LLWebProfile::uploadImageCoro(LLCoros::self& self, LLPointer<LLImageFormatt
 /*static*/
 LLCore::BufferArray::ptr_t LLWebProfile::buildPostData(const LLSD &data, LLPointer<LLImageFormatted> &image, const std::string &boundary)
 {
-    LLCore::BufferArray::ptr_t body(new LLCore::BufferArray, false);
+    LLCore::BufferArray::ptr_t body(new LLCore::BufferArray);
     LLCore::BufferArrayStream bas(body.get());
 
     // *NOTE: The order seems to matter.
diff --git a/indra/newview/llxmlrpctransaction.cpp b/indra/newview/llxmlrpctransaction.cpp
index 702d0c3a29..066970614a 100755
--- a/indra/newview/llxmlrpctransaction.cpp
+++ b/indra/newview/llxmlrpctransaction.cpp
@@ -357,7 +357,7 @@ void LLXMLRPCTransaction::Impl::init(XMLRPC_REQUEST request, bool useGzip)
 	}
 
 	// LLRefCounted starts with a 1 ref, so don't add a ref in the smart pointer
-	httpOpts = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false); 
+	httpOpts = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()); 
 
 	httpOpts->setTimeout(40L);
 
@@ -368,7 +368,7 @@ void LLXMLRPCTransaction::Impl::init(XMLRPC_REQUEST request, bool useGzip)
 	httpOpts->setSSLVerifyHost( vefifySSLCert ? 2 : 0);
 
 	// LLRefCounted starts with a 1 ref, so don't add a ref in the smart pointer
-	httpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false);
+	httpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders());
 
 	httpHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, HTTP_CONTENT_TEXT_XML);
 
@@ -376,7 +376,7 @@ void LLXMLRPCTransaction::Impl::init(XMLRPC_REQUEST request, bool useGzip)
 	//This might help with bug #503 */
 	//httpOpts->setDNSCacheTimeout(-1);
 
-	LLCore::BufferArray::ptr_t body = LLCore::BufferArray::ptr_t(new LLCore::BufferArray(), false);
+	LLCore::BufferArray::ptr_t body = LLCore::BufferArray::ptr_t(new LLCore::BufferArray());
 
 	// TODO: See if there is a way to serialize to a preallocated buffer I'm 
 	// not fond of the copy here.
-- 
cgit v1.3


From 1138c57f9a8553903199e727912d7f1b092697e4 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 8 Jul 2015 10:01:27 -0700
Subject: Convert LLCore::HttpHeaders to use shared_ptr<> rather than an
 intrusive_ptr<> for refrence counting.

---
 indra/llcorehttp/_httplibcurl.cpp         |  2 +-
 indra/llcorehttp/_httpoprequest.cpp       | 41 ++++++++++---------------------
 indra/llcorehttp/_httpoprequest.h         | 23 ++++++++---------
 indra/llcorehttp/httpheaders.cpp          |  1 -
 indra/llcorehttp/httpheaders.h            |  7 +++---
 indra/llcorehttp/httprequest.cpp          | 14 +++++------
 indra/llcorehttp/httprequest.h            | 15 +++++------
 indra/llcorehttp/httpresponse.cpp         | 21 +++-------------
 indra/llcorehttp/httpresponse.h           | 12 ++++-----
 indra/llcrashlogger/llcrashlogger.cpp     |  2 +-
 indra/llmessage/llcorehttputil.cpp        | 14 +++++------
 indra/llmessage/llcorehttputil.h          | 18 +++++++-------
 indra/newview/llassetuploadresponders.cpp |  2 ++
 indra/newview/llassetuploadresponders.h   |  3 ++-
 indra/newview/llhttpretrypolicy.cpp       |  4 +--
 indra/newview/llhttpretrypolicy.h         |  2 +-
 indra/newview/llinventorymodel.cpp        | 10 +++-----
 indra/newview/llinventorymodel.h          |  2 +-
 indra/newview/llmaterialmgr.cpp           |  2 +-
 indra/newview/llmeshrepository.cpp        | 17 +++----------
 indra/newview/llmeshrepository.h          |  4 +--
 indra/newview/lltexturefetch.cpp          | 29 +++++-----------------
 indra/newview/lltexturefetch.h            |  8 +++---
 indra/newview/llviewerassetupload.cpp     |  4 +++
 indra/newview/llviewerassetupload.h       | 13 ++++++++++
 indra/newview/llxmlrpctransaction.cpp     |  2 +-
 26 files changed, 118 insertions(+), 154 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/_httplibcurl.cpp b/indra/llcorehttp/_httplibcurl.cpp
index 81b44ab90b..17e997688f 100755
--- a/indra/llcorehttp/_httplibcurl.cpp
+++ b/indra/llcorehttp/_httplibcurl.cpp
@@ -554,7 +554,7 @@ void HttpLibcurl::HandleCache::freeHandle(CURL * handle)
 // ---------------------------------------
 
 
-struct curl_slist * append_headers_to_slist(const HttpHeaders * headers, struct curl_slist * slist)
+struct curl_slist * append_headers_to_slist(const HttpHeaders::ptr_t &headers, struct curl_slist * slist)
 {
 	const HttpHeaders::const_iterator end(headers->end());
 	for (HttpHeaders::const_iterator it(headers->begin()); end != it; ++it)
diff --git a/indra/llcorehttp/_httpoprequest.cpp b/indra/llcorehttp/_httpoprequest.cpp
index 799587ff22..5d118a9afb 100755
--- a/indra/llcorehttp/_httpoprequest.cpp
+++ b/indra/llcorehttp/_httpoprequest.cpp
@@ -122,7 +122,7 @@ HttpOpRequest::HttpOpRequest()
 	  mReqBody(NULL),
 	  mReqOffset(0),
 	  mReqLength(0),
-	  mReqHeaders(NULL),
+	  mReqHeaders(),
 	  mReqOptions(NULL),
 	  mCurlActive(false),
 	  mCurlHandle(NULL),
@@ -135,7 +135,7 @@ HttpOpRequest::HttpOpRequest()
 	  mReplyOffset(0),
 	  mReplyLength(0),
 	  mReplyFullLength(0),
-	  mReplyHeaders(NULL),
+	  mReplyHeaders(),
 	  mPolicyRetries(0),
 	  mPolicy503Retries(0),
 	  mPolicyRetryAt(HttpTime(0)),
@@ -162,12 +162,6 @@ HttpOpRequest::~HttpOpRequest()
 		mReqOptions = NULL;
 	}
 
-	if (mReqHeaders)
-	{
-		mReqHeaders->release();
-		mReqHeaders = NULL;
-	}
-
 	if (mCurlHandle)
 	{
 		// Uncertain of thread context so free using
@@ -194,11 +188,6 @@ HttpOpRequest::~HttpOpRequest()
 		mReplyBody = NULL;
 	}
 
-	if (mReplyHeaders)
-	{
-		mReplyHeaders->release();
-		mReplyHeaders = NULL;
-	}
 }
 
 
@@ -299,7 +288,7 @@ HttpStatus HttpOpRequest::setupGet(HttpRequest::policy_t policy_id,
 								   HttpRequest::priority_t priority,
 								   const std::string & url,
 								   HttpOptions * options,
-								   HttpHeaders * headers)
+								   HttpHeaders::ptr_t &headers)
 {
 	setupCommon(policy_id, priority, url, NULL, options, headers);
 	mReqMethod = HOR_GET;
@@ -314,7 +303,7 @@ HttpStatus HttpOpRequest::setupGetByteRange(HttpRequest::policy_t policy_id,
 											size_t offset,
 											size_t len,
 											HttpOptions * options,
-											HttpHeaders * headers)
+                                            HttpHeaders::ptr_t &headers)
 {
 	setupCommon(policy_id, priority, url, NULL, options, headers);
 	mReqMethod = HOR_GET;
@@ -334,7 +323,7 @@ HttpStatus HttpOpRequest::setupPost(HttpRequest::policy_t policy_id,
 									const std::string & url,
 									BufferArray * body,
 									HttpOptions * options,
-									HttpHeaders * headers)
+                                    HttpHeaders::ptr_t &headers)
 {
 	setupCommon(policy_id, priority, url, body, options, headers);
 	mReqMethod = HOR_POST;
@@ -348,7 +337,7 @@ HttpStatus HttpOpRequest::setupPut(HttpRequest::policy_t policy_id,
 								   const std::string & url,
 								   BufferArray * body,
 								   HttpOptions * options,
-								   HttpHeaders * headers)
+								   HttpHeaders::ptr_t &headers)
 {
 	setupCommon(policy_id, priority, url, body, options, headers);
 	mReqMethod = HOR_PUT;
@@ -361,7 +350,7 @@ HttpStatus HttpOpRequest::setupDelete(HttpRequest::policy_t policy_id,
     HttpRequest::priority_t priority,
     const std::string & url,
     HttpOptions * options,
-    HttpHeaders * headers)
+    HttpHeaders::ptr_t &headers)
 {
     setupCommon(policy_id, priority, url, NULL, options, headers);
     mReqMethod = HOR_DELETE;
@@ -375,7 +364,7 @@ HttpStatus HttpOpRequest::setupPatch(HttpRequest::policy_t policy_id,
     const std::string & url,
     BufferArray * body,
     HttpOptions * options,
-    HttpHeaders * headers)
+    HttpHeaders::ptr_t &headers)
 {
     setupCommon(policy_id, priority, url, body, options, headers);
     mReqMethod = HOR_PATCH;
@@ -388,7 +377,7 @@ HttpStatus HttpOpRequest::setupCopy(HttpRequest::policy_t policy_id,
     HttpRequest::priority_t priority,
     const std::string & url,
     HttpOptions * options,
-    HttpHeaders * headers)
+    HttpHeaders::ptr_t &headers)
 {
     setupCommon(policy_id, priority, url, NULL, options, headers);
     mReqMethod = HOR_COPY;
@@ -402,7 +391,7 @@ void HttpOpRequest::setupCommon(HttpRequest::policy_t policy_id,
 								const std::string & url,
 								BufferArray * body,
 								HttpOptions * options,
-								HttpHeaders * headers)
+								HttpHeaders::ptr_t &headers)
 {
 	mProcFlags = 0U;
 	mReqPolicy = policy_id;
@@ -415,7 +404,7 @@ void HttpOpRequest::setupCommon(HttpRequest::policy_t policy_id,
 	}
 	if (headers && ! mReqHeaders)
 	{
-		headers->addRef();
+		//headers->addRef();
 		mReqHeaders = headers;
 	}
 	if (options && ! mReqOptions)
@@ -467,11 +456,7 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 	mReplyOffset = 0;
 	mReplyLength = 0;
 	mReplyFullLength = 0;
-	if (mReplyHeaders)
-	{
-		mReplyHeaders->release();
-		mReplyHeaders = NULL;
-	}
+    mReplyHeaders.reset();
 	mReplyConType.clear();
 	
 	// *FIXME:  better error handling later
@@ -946,7 +931,7 @@ size_t HttpOpRequest::headerCallback(void * data, size_t size, size_t nmemb, voi
 		// Save headers in response
 		if (! op->mReplyHeaders)
 		{
-			op->mReplyHeaders = new HttpHeaders;
+			op->mReplyHeaders = HttpHeaders::ptr_t(new HttpHeaders);
 		}
 		op->mReplyHeaders->append(name, value ? value : "");
 	}
diff --git a/indra/llcorehttp/_httpoprequest.h b/indra/llcorehttp/_httpoprequest.h
index b1bb101bea..0465c2b83f 100755
--- a/indra/llcorehttp/_httpoprequest.h
+++ b/indra/llcorehttp/_httpoprequest.h
@@ -41,6 +41,7 @@
 #include "_httpoperation.h"
 #include "_refcounted.h"
 
+#include "httpheaders.h"
 
 namespace LLCore
 {
@@ -105,7 +106,7 @@ public:
 						HttpRequest::priority_t priority,
 						const std::string & url,
 						HttpOptions * options,
-						HttpHeaders * headers);
+						HttpHeaders::ptr_t & headers);
 	
 	HttpStatus setupGetByteRange(HttpRequest::policy_t policy_id,
 								 HttpRequest::priority_t priority,
@@ -113,40 +114,40 @@ public:
 								 size_t offset,
 								 size_t len,
 								 HttpOptions * options,
-								 HttpHeaders * headers);
+								 HttpHeaders::ptr_t & headers);
 	
 	HttpStatus setupPost(HttpRequest::policy_t policy_id,
 						 HttpRequest::priority_t priority,
 						 const std::string & url,
 						 BufferArray * body,
 						 HttpOptions * options,
-						 HttpHeaders * headers);
+						 HttpHeaders::ptr_t & headers);
 	
 	HttpStatus setupPut(HttpRequest::policy_t policy_id,
 						HttpRequest::priority_t priority,
 						const std::string & url,
 						BufferArray * body,
 						HttpOptions * options,
-						HttpHeaders * headers);
+						HttpHeaders::ptr_t & headers);
 
     HttpStatus setupDelete(HttpRequest::policy_t policy_id,
                         HttpRequest::priority_t priority,
                         const std::string & url,
                         HttpOptions * options,
-                        HttpHeaders * headers);
+                        HttpHeaders::ptr_t & headers);
 
     HttpStatus setupPatch(HttpRequest::policy_t policy_id,
                         HttpRequest::priority_t priority,
                         const std::string & url,
                         BufferArray * body,
                         HttpOptions * options,
-                        HttpHeaders * headers);
+                        HttpHeaders::ptr_t & headers);
 
     HttpStatus setupCopy(HttpRequest::policy_t policy_id,
                         HttpRequest::priority_t priority,
                         const std::string & url,
                         HttpOptions * options,
-                        HttpHeaders * headers);
+                        HttpHeaders::ptr_t & headers);
 
     // Internal method used to setup the libcurl options for a request.
 	// Does all the libcurl handle setup in one place.
@@ -167,7 +168,7 @@ protected:
 					 const std::string & url,
 					 BufferArray * body,
 					 HttpOptions * options,
-					 HttpHeaders * headers);
+					 HttpHeaders::ptr_t &headers);
 
 	// libcurl operational callbacks
 	//
@@ -197,7 +198,7 @@ public:
 	BufferArray *		mReqBody;
 	off_t				mReqOffset;
 	size_t				mReqLength;
-	HttpHeaders *		mReqHeaders;
+	HttpHeaders::ptr_t	mReqHeaders;
 	HttpOptions *		mReqOptions;
 
 	// Transport data
@@ -215,7 +216,7 @@ public:
 	off_t				mReplyOffset;
 	size_t				mReplyLength;
 	size_t				mReplyFullLength;
-	HttpHeaders *		mReplyHeaders;
+	HttpHeaders::ptr_t	mReplyHeaders;
 	std::string			mReplyConType;
 	int					mReplyRetryAfter;
 
@@ -246,7 +247,7 @@ public:
 
 // Internal function to append the contents of an HttpHeaders
 // instance to a curl_slist object.
-curl_slist * append_headers_to_slist(const HttpHeaders *, curl_slist * slist);
+curl_slist * append_headers_to_slist(const HttpHeaders::ptr_t &, curl_slist * slist);
 
 }   // end namespace LLCore
 
diff --git a/indra/llcorehttp/httpheaders.cpp b/indra/llcorehttp/httpheaders.cpp
index e03b1b080d..f586191a7c 100755
--- a/indra/llcorehttp/httpheaders.cpp
+++ b/indra/llcorehttp/httpheaders.cpp
@@ -34,7 +34,6 @@ namespace LLCore
 
 
 HttpHeaders::HttpHeaders()
-	: RefCounted(true)
 {}
 
 
diff --git a/indra/llcorehttp/httpheaders.h b/indra/llcorehttp/httpheaders.h
index 8f14568fa3..a97bae5537 100755
--- a/indra/llcorehttp/httpheaders.h
+++ b/indra/llcorehttp/httpheaders.h
@@ -74,7 +74,7 @@ namespace LLCore
 /// constructor is given a refcount.
 ///
 
-class HttpHeaders : public LLCoreInt::RefCounted
+class HttpHeaders: private boost::noncopyable
 {
 public:
 	typedef std::pair<std::string, std::string> header_t;
@@ -91,10 +91,11 @@ public:
 	/// to the instance.  A call to @see release() will destroy
 	/// the instance.
 	HttpHeaders();
+    virtual ~HttpHeaders();						// Use release()
 
-	typedef LLCoreInt::IntrusivePtr<HttpHeaders> ptr_t;
+	//typedef LLCoreInt::IntrusivePtr<HttpHeaders> ptr_t;
+    typedef boost::shared_ptr<HttpHeaders> ptr_t;
 protected:
-	virtual ~HttpHeaders();						// Use release()
 
 	HttpHeaders(const HttpHeaders &);			// Not defined
 	void operator=(const HttpHeaders &);		// Not defined
diff --git a/indra/llcorehttp/httprequest.cpp b/indra/llcorehttp/httprequest.cpp
index d4c60a6f14..b5ea0b44b0 100755
--- a/indra/llcorehttp/httprequest.cpp
+++ b/indra/llcorehttp/httprequest.cpp
@@ -198,7 +198,7 @@ HttpHandle HttpRequest::requestGet(policy_t policy_id,
 								   priority_t priority,
 								   const std::string & url,
 								   HttpOptions * options,
-								   HttpHeaders * headers,
+								   HttpHeaders::ptr_t &headers,
 								   HttpHandler * user_handler)
 {
 	HttpStatus status;
@@ -232,7 +232,7 @@ HttpHandle HttpRequest::requestGetByteRange(policy_t policy_id,
 											size_t offset,
 											size_t len,
 											HttpOptions * options,
-											HttpHeaders * headers,
+											HttpHeaders::ptr_t &headers,
 											HttpHandler * user_handler)
 {
 	HttpStatus status;
@@ -265,7 +265,7 @@ HttpHandle HttpRequest::requestPost(policy_t policy_id,
 									const std::string & url,
 									BufferArray * body,
 									HttpOptions * options,
-									HttpHeaders * headers,
+									HttpHeaders::ptr_t &headers,
 									HttpHandler * user_handler)
 {
 	HttpStatus status;
@@ -298,7 +298,7 @@ HttpHandle HttpRequest::requestPut(policy_t policy_id,
 								   const std::string & url,
 								   BufferArray * body,
 								   HttpOptions * options,
-								   HttpHeaders * headers,
+								   HttpHeaders::ptr_t &headers,
 								   HttpHandler * user_handler)
 {
 	HttpStatus status;
@@ -329,7 +329,7 @@ HttpHandle HttpRequest::requestDelete(policy_t policy_id,
     priority_t priority,
     const std::string & url,
     HttpOptions * options,
-    HttpHeaders * headers,
+    HttpHeaders::ptr_t &headers,
     HttpHandler * user_handler)
 {
     HttpStatus status;
@@ -361,7 +361,7 @@ HttpHandle HttpRequest::requestPatch(policy_t policy_id,
     const std::string & url,
     BufferArray * body,
     HttpOptions * options,
-    HttpHeaders * headers,
+    HttpHeaders::ptr_t &headers,
     HttpHandler * user_handler)
 {
     HttpStatus status;
@@ -392,7 +392,7 @@ HttpHandle HttpRequest::requestCopy(policy_t policy_id,
     priority_t priority,
     const std::string & url,
     HttpOptions * options,
-    HttpHeaders * headers,
+    HttpHeaders::ptr_t &headers,
     HttpHandler * user_handler)
 {
     HttpStatus status;
diff --git a/indra/llcorehttp/httprequest.h b/indra/llcorehttp/httprequest.h
index e87a8b691a..c0622372e1 100755
--- a/indra/llcorehttp/httprequest.h
+++ b/indra/llcorehttp/httprequest.h
@@ -31,6 +31,7 @@
 #include "httpcommon.h"
 #include "httphandler.h"
 
+#include "httpheaders.h"
 
 namespace LLCore
 {
@@ -349,7 +350,7 @@ public:
 						  priority_t priority,
 						  const std::string & url,
 						  HttpOptions * options,
-						  HttpHeaders * headers,
+						  HttpHeaders::ptr_t &headers,
 						  HttpHandler * handler);
 
 
@@ -392,7 +393,7 @@ public:
 								   size_t offset,
 								   size_t len,
 								   HttpOptions * options,
-								   HttpHeaders * headers,
+								   HttpHeaders::ptr_t &headers,
 								   HttpHandler * handler);
 
 
@@ -433,7 +434,7 @@ public:
 						   const std::string & url,
 						   BufferArray * body,
 						   HttpOptions * options,
-						   HttpHeaders * headers,
+						   HttpHeaders::ptr_t &headers,
 						   HttpHandler * handler);
 
 
@@ -474,7 +475,7 @@ public:
 						  const std::string & url,
 						  BufferArray * body,
 						  HttpOptions * options,
-						  HttpHeaders * headers,
+						  HttpHeaders::ptr_t &headers,
 						  HttpHandler * handler);
 
 
@@ -494,7 +495,7 @@ public:
             priority_t priority,
             const std::string & url,
             HttpOptions * options,
-            HttpHeaders * headers,
+            HttpHeaders::ptr_t &headers,
             HttpHandler * user_handler);
 
     /// Queue a full HTTP PUT.  Query arguments and body may
@@ -517,7 +518,7 @@ public:
             const std::string & url,
             BufferArray * body,
             HttpOptions * options,
-            HttpHeaders * headers,
+            HttpHeaders::ptr_t &headers,
             HttpHandler * user_handler);
 
     /// Queue a full HTTP PUT.  Query arguments and body may
@@ -536,7 +537,7 @@ public:
             priority_t priority,
             const std::string & url,
             HttpOptions * options,
-            HttpHeaders * headers,
+            HttpHeaders::ptr_t &headers,
             HttpHandler * user_handler);
        
     /// Queue a NoOp request.
diff --git a/indra/llcorehttp/httpresponse.cpp b/indra/llcorehttp/httpresponse.cpp
index 7d88f02527..f5ad2ebd47 100755
--- a/indra/llcorehttp/httpresponse.cpp
+++ b/indra/llcorehttp/httpresponse.cpp
@@ -39,7 +39,7 @@ HttpResponse::HttpResponse()
 	  mReplyLength(0U),
 	  mReplyFullLength(0U),
 	  mBufferArray(NULL),
-	  mHeaders(NULL),
+	  mHeaders(),
 	  mRetries(0U),
 	  m503Retries(0U),
       mRequestUrl()
@@ -49,7 +49,7 @@ HttpResponse::HttpResponse()
 HttpResponse::~HttpResponse()
 {
 	setBody(NULL);
-	setHeaders(NULL);
+	//setHeaders();
 }
 
 
@@ -72,22 +72,9 @@ void HttpResponse::setBody(BufferArray * ba)
 }
 
 
-void HttpResponse::setHeaders(HttpHeaders * headers)
+void HttpResponse::setHeaders(HttpHeaders::ptr_t &headers)
 {
-	if (mHeaders == headers)
-		return;
-	
-	if (mHeaders)
-	{
-		mHeaders->release();
-	}
-
-	if (headers)
-	{
-		headers->addRef();
-	}
-	
-	mHeaders = headers;
+    mHeaders = headers;
 }
 
 size_t HttpResponse::getBodySize() const
diff --git a/indra/llcorehttp/httpresponse.h b/indra/llcorehttp/httpresponse.h
index 6c3b4da5e6..0bfa4585c7 100755
--- a/indra/llcorehttp/httpresponse.h
+++ b/indra/llcorehttp/httpresponse.h
@@ -31,7 +31,7 @@
 #include <string>
 
 #include "httpcommon.h"
-
+#include "httpheaders.h"
 #include "_refcounted.h"
 
 
@@ -120,13 +120,13 @@ public:
 	///
 	/// Caller can hold onto the headers by incrementing the reference
 	/// count of the returned object.
-	HttpHeaders * getHeaders() const
-		{
+	HttpHeaders::ptr_t getHeaders() const
+	{
 			return mHeaders;
-		}
+	}
 
 	/// Behaves like @see setResponse() but for header data.
-	void setHeaders(HttpHeaders * headers);
+	void setHeaders(HttpHeaders::ptr_t &headers);
 
 	/// If a 'Range:' header was used, these methods are involved
 	/// in setting and returning data about the actual response.
@@ -212,7 +212,7 @@ protected:
 	unsigned int		mReplyLength;
 	unsigned int		mReplyFullLength;
 	BufferArray *		mBufferArray;
-	HttpHeaders *		mHeaders;
+	HttpHeaders::ptr_t	mHeaders;
 	std::string			mContentType;
 	unsigned int		mRetries;
 	unsigned int		m503Retries;
diff --git a/indra/llcrashlogger/llcrashlogger.cpp b/indra/llcrashlogger/llcrashlogger.cpp
index cb05c4ff03..ed585ff64e 100755
--- a/indra/llcrashlogger/llcrashlogger.cpp
+++ b/indra/llcrashlogger/llcrashlogger.cpp
@@ -407,7 +407,7 @@ bool LLCrashLogger::runCrashLogPost(std::string host, LLSD data, std::string msg
 		updateApplication(llformat("%s, try %d...", msg.c_str(), i+1));
 
         LLCoreHttpUtil::requestPostWithLLSD(httpRequest.get(), LLCore::HttpRequest::DEFAULT_POLICY_ID, 0,
-            host, data, httpOpts.get(), NULL, new LLCrashLoggerHandler);
+            host, data, httpOpts.get(), LLCore::HttpHeaders::ptr_t(), new LLCrashLoggerHandler);
 
         while(!gBreak)
 		{
diff --git a/indra/llmessage/llcorehttputil.cpp b/indra/llmessage/llcorehttputil.cpp
index 4ec01aa405..e3588b74ee 100644
--- a/indra/llmessage/llcorehttputil.cpp
+++ b/indra/llmessage/llcorehttputil.cpp
@@ -103,7 +103,7 @@ HttpHandle requestPostWithLLSD(HttpRequest * request,
     const std::string & url,
     const LLSD & body,
     HttpOptions * options,
-    HttpHeaders * headers,
+    HttpHeaders::ptr_t &headers,
     HttpHandler * handler)
 {
     HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
@@ -130,7 +130,7 @@ HttpHandle requestPutWithLLSD(HttpRequest * request,
     const std::string & url,
     const LLSD & body,
     HttpOptions * options,
-    HttpHeaders * headers,
+    HttpHeaders::ptr_t &headers,
     HttpHandler * handler)
 {
     HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
@@ -156,7 +156,7 @@ HttpHandle requestPatchWithLLSD(HttpRequest * request,
     const std::string & url,
     const LLSD & body,
     HttpOptions * options,
-    HttpHeaders * headers,
+    HttpHeaders::ptr_t &headers,
     HttpHandler * handler)
 {
     HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
@@ -286,7 +286,7 @@ void HttpCoroHandler::buildStatusEntry(LLCore::HttpResponse *response, LLCore::H
     writeStatusCodes(status, response->getRequestURL(), httpresults);
 
     LLSD httpHeaders = LLSD::emptyMap();
-    LLCore::HttpHeaders * hdrs = response->getHeaders();
+    LLCore::HttpHeaders::ptr_t hdrs = response->getHeaders();
 
     if (hdrs)
     {
@@ -689,7 +689,7 @@ LLSD HttpCoroutineAdapter::postAndYield_(LLCoros::self & self, LLCore::HttpReque
     // 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->requestPost(mPolicyId, mPriority, url, rawbody.get(),
-        options.get(), headers.get(), handler.get());
+        options.get(), headers, handler.get());
 
     if (hhandle == LLCORE_HTTP_HANDLE_INVALID)
     {
@@ -782,7 +782,7 @@ LLSD HttpCoroutineAdapter::getAndYield_(LLCoros::self & self, LLCore::HttpReques
     // 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->requestGet(mPolicyId, mPriority,
-        url, options.get(), headers.get(), handler.get());
+        url, options.get(), headers, handler.get());
 
     if (hhandle == LLCORE_HTTP_HANDLE_INVALID)
     {
@@ -817,7 +817,7 @@ LLSD HttpCoroutineAdapter::deleteAndYield_(LLCoros::self & self, LLCore::HttpReq
     // 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->requestDelete(mPolicyId, mPriority,
-        url, options.get(), headers.get(), handler.get());
+        url, options.get(), headers, handler.get());
 
     if (hhandle == LLCORE_HTTP_HANDLE_INVALID)
     {
diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 7dd161d1cd..a54f94e6f0 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -112,7 +112,7 @@ LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest * request,
 									   const std::string & url,
 									   const LLSD & body,
 									   LLCore::HttpOptions * options,
-									   LLCore::HttpHeaders * headers,
+									   LLCore::HttpHeaders::ptr_t &headers,
 									   LLCore::HttpHandler * handler);
 
 inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -125,7 +125,7 @@ inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & reque
 	LLCore::HttpHandler * handler)
 {
     return requestPostWithLLSD(request.get(), policy_id, priority,
-        url, body, options.get(), headers.get(), handler);
+        url, body, options.get(), headers, handler);
 }
 
 inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -136,7 +136,7 @@ inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & reque
     LLCore::HttpHandler * handler)
 {
     return requestPostWithLLSD(request.get(), policy_id, priority,
-        url, body, NULL, NULL, handler);
+        url, body, NULL, LLCore::HttpHeaders::ptr_t(), handler);
 }
 
 
@@ -162,7 +162,7 @@ LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest * request,
 	const std::string & url,
 	const LLSD & body,
 	LLCore::HttpOptions * options,
-	LLCore::HttpHeaders * headers,
+	LLCore::HttpHeaders::ptr_t &headers,
 	LLCore::HttpHandler * handler);
 
 inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -175,7 +175,7 @@ inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & reques
 	LLCore::HttpHandler * handler)
 {
     return requestPutWithLLSD(request.get(), policy_id, priority,
-        url, body, options.get(), headers.get(), handler);
+        url, body, options.get(), headers, handler);
 }
 
 inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -186,7 +186,7 @@ inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & reques
     LLCore::HttpHandler * handler)
 {
     return requestPutWithLLSD(request.get(), policy_id, priority,
-        url, body, NULL, NULL, handler);
+        url, body, NULL, LLCore::HttpHeaders::ptr_t(), handler);
 }
 
 /// Issue a standard HttpRequest::requestPatch() call but using
@@ -211,7 +211,7 @@ LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest * request,
     const std::string & url,
     const LLSD & body,
     LLCore::HttpOptions * options,
-    LLCore::HttpHeaders * headers,
+    LLCore::HttpHeaders::ptr_t &headers,
     LLCore::HttpHandler * handler);
 
 inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -224,7 +224,7 @@ inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & requ
     LLCore::HttpHandler * handler)
 {
     return requestPatchWithLLSD(request.get(), policy_id, priority,
-        url, body, options.get(), headers.get(), handler);
+        url, body, options.get(), headers, handler);
 }
 
 inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -235,7 +235,7 @@ inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & requ
     LLCore::HttpHandler * handler)
 {
     return requestPatchWithLLSD(request.get(), policy_id, priority,
-        url, body, NULL, NULL, handler);
+        url, body, NULL, LLCore::HttpHeaders::ptr_t(), handler);
 }
 
 //=========================================================================
diff --git a/indra/newview/llassetuploadresponders.cpp b/indra/newview/llassetuploadresponders.cpp
index e492b8cf5d..fe01288e23 100755
--- a/indra/newview/llassetuploadresponders.cpp
+++ b/indra/newview/llassetuploadresponders.cpp
@@ -352,6 +352,7 @@ void LLAssetUploadResponder::uploadComplete(const LLSD& content)
 {
 }
 
+#if 0
 LLNewAgentInventoryResponder::LLNewAgentInventoryResponder(
 	const LLSD& post_data,
 	const LLUUID& vfile_id,
@@ -473,6 +474,7 @@ void LLNewAgentInventoryResponder::uploadComplete(const LLSD& content)
 
 	//LLImportColladaAssetCache::getInstance()->assetUploaded(mVFileID, content["new_asset"], TRUE);
 }
+#endif
 
 LLUpdateAgentInventoryResponder::LLUpdateAgentInventoryResponder(
 	const LLSD& post_data,
diff --git a/indra/newview/llassetuploadresponders.h b/indra/newview/llassetuploadresponders.h
index 18968bb1af..6828678f09 100755
--- a/indra/newview/llassetuploadresponders.h
+++ b/indra/newview/llassetuploadresponders.h
@@ -60,6 +60,7 @@ protected:
 	std::string mFileName;
 };
 
+#if 0
 // TODO*: Remove this once deprecated
 class LLNewAgentInventoryResponder : public LLAssetUploadResponder
 {
@@ -78,7 +79,7 @@ public:
 protected:
 	virtual void httpFailure();
 };
-
+#endif
 #if 0
 // A base class which goes through and performs some default
 // actions for variable price uploads.  If more specific actions
diff --git a/indra/newview/llhttpretrypolicy.cpp b/indra/newview/llhttpretrypolicy.cpp
index 530eb685fa..e2e151eb63 100755
--- a/indra/newview/llhttpretrypolicy.cpp
+++ b/indra/newview/llhttpretrypolicy.cpp
@@ -56,7 +56,7 @@ bool LLAdaptiveRetryPolicy::getRetryAfter(const LLSD& headers, F32& retry_header
 			&& getSecondsUntilRetryAfter(headers[HTTP_IN_HEADER_RETRY_AFTER].asStringRef(), retry_header_time));
 }
 
-bool LLAdaptiveRetryPolicy::getRetryAfter(const LLCore::HttpHeaders *headers, F32& retry_header_time)
+bool LLAdaptiveRetryPolicy::getRetryAfter(const LLCore::HttpHeaders::ptr_t &headers, F32& retry_header_time)
 {
 	if (headers)
 	{
@@ -85,7 +85,7 @@ void LLAdaptiveRetryPolicy::onFailure(S32 status, const LLSD& headers)
 void LLAdaptiveRetryPolicy::onFailure(const LLCore::HttpResponse *response)
 {
 	F32 retry_header_time;
-	const LLCore::HttpHeaders *headers = response->getHeaders();
+	const LLCore::HttpHeaders::ptr_t headers = response->getHeaders();
 	bool has_retry_header_time = getRetryAfter(headers,retry_header_time);
 	onFailureCommon(response->getStatus().getType(), has_retry_header_time, retry_header_time);
 }
diff --git a/indra/newview/llhttpretrypolicy.h b/indra/newview/llhttpretrypolicy.h
index cf79e0b401..c0cc263546 100755
--- a/indra/newview/llhttpretrypolicy.h
+++ b/indra/newview/llhttpretrypolicy.h
@@ -79,7 +79,7 @@ public:
 protected:
 	void init();
 	bool getRetryAfter(const LLSD& headers, F32& retry_header_time);
-	bool getRetryAfter(const LLCore::HttpHeaders *headers, F32& retry_header_time);
+	bool getRetryAfter(const LLCore::HttpHeaders::ptr_t &headers, F32& retry_header_time);
 	void onFailureCommon(S32 status, bool has_retry_header_time, F32 retry_header_time);
 
 private:
diff --git a/indra/newview/llinventorymodel.cpp b/indra/newview/llinventorymodel.cpp
index 6d21dd4ba7..cf550c20c5 100755
--- a/indra/newview/llinventorymodel.cpp
+++ b/indra/newview/llinventorymodel.cpp
@@ -149,7 +149,7 @@ LLInventoryModel::LLInventoryModel()
 	mHttpRequestFG(NULL),
 	mHttpRequestBG(NULL),
 	mHttpOptions(NULL),
-	mHttpHeaders(NULL),
+	mHttpHeaders(),
 	mHttpPolicyClass(LLCore::HttpRequest::DEFAULT_POLICY_ID),
 	mHttpPriorityFG(0),
 	mHttpPriorityBG(0),
@@ -178,11 +178,7 @@ void LLInventoryModel::cleanupInventory()
 	mObservers.clear();
 
 	// Run down HTTP transport
-	if (mHttpHeaders)
-	{
-		mHttpHeaders->release();
-		mHttpHeaders = NULL;
-	}
+    mHttpHeaders.reset();
 	if (mHttpOptions)
 	{
 		mHttpOptions->release();
@@ -2422,7 +2418,7 @@ void LLInventoryModel::initHttpRequest()
 		mHttpOptions->setTransferTimeout(300);
 		mHttpOptions->setUseRetryAfter(true);
 		// mHttpOptions->setTrace(2);		// Do tracing of requests
-		mHttpHeaders = new LLCore::HttpHeaders;
+        mHttpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders);
 		mHttpHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, HTTP_CONTENT_LLSD_XML);
 		mHttpHeaders->append(HTTP_OUT_HEADER_ACCEPT, HTTP_CONTENT_LLSD_XML);
 		mHttpPolicyClass = app_core_http.getPolicy(LLAppCoreHttp::AP_INVENTORY);
diff --git a/indra/newview/llinventorymodel.h b/indra/newview/llinventorymodel.h
index 26ee06535a..9711fb95f6 100755
--- a/indra/newview/llinventorymodel.h
+++ b/indra/newview/llinventorymodel.h
@@ -572,7 +572,7 @@ private:
 	LLCore::HttpRequest *				mHttpRequestFG;
 	LLCore::HttpRequest *				mHttpRequestBG;
 	LLCore::HttpOptions *				mHttpOptions;
-	LLCore::HttpHeaders *				mHttpHeaders;
+	LLCore::HttpHeaders::ptr_t			mHttpHeaders;
 	LLCore::HttpRequest::policy_t		mHttpPolicyClass;
 	LLCore::HttpRequest::priority_t		mHttpPriorityFG;
 	LLCore::HttpRequest::priority_t		mHttpPriorityBG;
diff --git a/indra/newview/llmaterialmgr.cpp b/indra/newview/llmaterialmgr.cpp
index aef5bcf0dd..e6f3540877 100755
--- a/indra/newview/llmaterialmgr.cpp
+++ b/indra/newview/llmaterialmgr.cpp
@@ -712,7 +712,7 @@ void LLMaterialMgr::processGetAllQueue()
 			);
 
 		LLCore::HttpHandle handle = mHttpRequest->requestGet(mHttpPolicy, mHttpPriority, capURL,
-				mHttpOptions.get(), mHttpHeaders.get(), handler);
+				mHttpOptions.get(), mHttpHeaders, handler);
 
 		if (handle == LLCORE_HTTP_HANDLE_INVALID)
 		{
diff --git a/indra/newview/llmeshrepository.cpp b/indra/newview/llmeshrepository.cpp
index 648056484e..7f8e357e33 100755
--- a/indra/newview/llmeshrepository.cpp
+++ b/indra/newview/llmeshrepository.cpp
@@ -740,7 +740,7 @@ LLMeshRepoThread::LLMeshRepoThread()
   mHttpRequest(NULL),
   mHttpOptions(NULL),
   mHttpLargeOptions(NULL),
-  mHttpHeaders(NULL),
+  mHttpHeaders(),
   mHttpPolicyClass(LLCore::HttpRequest::DEFAULT_POLICY_ID),
   mHttpLegacyPolicyClass(LLCore::HttpRequest::DEFAULT_POLICY_ID),
   mHttpLargePolicyClass(LLCore::HttpRequest::DEFAULT_POLICY_ID),
@@ -759,7 +759,7 @@ LLMeshRepoThread::LLMeshRepoThread()
 	mHttpLargeOptions = new LLCore::HttpOptions;
 	mHttpLargeOptions->setTransferTimeout(LARGE_MESH_XFER_TIMEOUT);
 	mHttpLargeOptions->setUseRetryAfter(gSavedSettings.getBOOL("MeshUseHttpRetryAfter"));
-	mHttpHeaders = new LLCore::HttpHeaders;
+	mHttpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders);
 	mHttpHeaders->append(HTTP_OUT_HEADER_ACCEPT, HTTP_CONTENT_VND_LL_MESH);
 	mHttpPolicyClass = app_core_http.getPolicy(LLAppCoreHttp::AP_MESH2);
 	mHttpLegacyPolicyClass = app_core_http.getPolicy(LLAppCoreHttp::AP_MESH1);
@@ -781,11 +781,7 @@ LLMeshRepoThread::~LLMeshRepoThread()
 		delete *iter;
 	}
 	mHttpRequestSet.clear();
-	if (mHttpHeaders)
-	{
-		mHttpHeaders->release();
-		mHttpHeaders = NULL;
-	}
+    mHttpHeaders.reset();
 	if (mHttpOptions)
 	{
 		mHttpOptions->release();
@@ -1886,7 +1882,7 @@ LLMeshUploadThread::LLMeshUploadThread(LLMeshUploadThread::instance_list& data,
 	mHttpOptions->setTransferTimeout(mMeshUploadTimeOut);
 	mHttpOptions->setUseRetryAfter(gSavedSettings.getBOOL("MeshUseHttpRetryAfter"));
 	mHttpOptions->setRetries(UPLOAD_RETRY_LIMIT);
-	mHttpHeaders = new LLCore::HttpHeaders;
+	mHttpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders);
 	mHttpHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, HTTP_CONTENT_LLSD_XML);
 	mHttpPolicyClass = LLAppViewer::instance()->getAppCoreHttp().getPolicy(LLAppCoreHttp::AP_UPLOADS);
 	mHttpPriority = 0;
@@ -1894,11 +1890,6 @@ LLMeshUploadThread::LLMeshUploadThread(LLMeshUploadThread::instance_list& data,
 
 LLMeshUploadThread::~LLMeshUploadThread()
 {
-	if (mHttpHeaders)
-	{
-		mHttpHeaders->release();
-		mHttpHeaders = NULL;
-	}
 	if (mHttpOptions)
 	{
 		mHttpOptions->release();
diff --git a/indra/newview/llmeshrepository.h b/indra/newview/llmeshrepository.h
index 39280bea3a..dc1fa883b3 100755
--- a/indra/newview/llmeshrepository.h
+++ b/indra/newview/llmeshrepository.h
@@ -324,7 +324,7 @@ public:
 	LLCore::HttpRequest *				mHttpRequest;
 	LLCore::HttpOptions *				mHttpOptions;
 	LLCore::HttpOptions *				mHttpLargeOptions;
-	LLCore::HttpHeaders *				mHttpHeaders;
+	LLCore::HttpHeaders::ptr_t			mHttpHeaders;
 	LLCore::HttpRequest::policy_t		mHttpPolicyClass;
 	LLCore::HttpRequest::policy_t		mHttpLegacyPolicyClass;
 	LLCore::HttpRequest::policy_t		mHttpLargePolicyClass;
@@ -494,7 +494,7 @@ private:
 	LLCore::HttpStatus					mHttpStatus;
 	LLCore::HttpRequest *				mHttpRequest;
 	LLCore::HttpOptions *				mHttpOptions;
-	LLCore::HttpHeaders *				mHttpHeaders;
+	LLCore::HttpHeaders::ptr_t			mHttpHeaders;
 	LLCore::HttpRequest::policy_t		mHttpPolicyClass;
 	LLCore::HttpRequest::priority_t		mHttpPriority;
 };
diff --git a/indra/newview/lltexturefetch.cpp b/indra/newview/lltexturefetch.cpp
index f4b1ff7313..1055216b65 100755
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
@@ -2511,9 +2511,9 @@ LLTextureFetch::LLTextureFetch(LLTextureCache* cache, LLImageDecodeThread* image
 	  mHttpRequest(NULL),
 	  mHttpOptions(NULL),
 	  mHttpOptionsWithHeaders(NULL),
-	  mHttpHeaders(NULL),
+	  mHttpHeaders(),
 	  mHttpPolicyClass(LLCore::HttpRequest::DEFAULT_POLICY_ID),
-	  mHttpMetricsHeaders(NULL),
+	  mHttpMetricsHeaders(),
 	  mHttpMetricsPolicyClass(LLCore::HttpRequest::DEFAULT_POLICY_ID),
 	  mTotalCacheReadCount(0U),
 	  mTotalCacheWriteCount(0U),
@@ -2531,10 +2531,10 @@ LLTextureFetch::LLTextureFetch(LLTextureCache* cache, LLImageDecodeThread* image
 	mHttpOptions = new LLCore::HttpOptions;
 	mHttpOptionsWithHeaders = new LLCore::HttpOptions;
 	mHttpOptionsWithHeaders->setWantHeaders(true);
-	mHttpHeaders = new LLCore::HttpHeaders;
+    mHttpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders);
 	mHttpHeaders->append(HTTP_OUT_HEADER_ACCEPT, HTTP_CONTENT_IMAGE_X_J2C);
 	mHttpPolicyClass = app_core_http.getPolicy(LLAppCoreHttp::AP_TEXTURE);
-	mHttpMetricsHeaders = new LLCore::HttpHeaders;
+    mHttpMetricsHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders);
 	mHttpMetricsHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, HTTP_CONTENT_LLSD_XML);
 	mHttpMetricsPolicyClass = app_core_http.getPolicy(LLAppCoreHttp::AP_REPORTING);
 	mHttpHighWater = HTTP_NONPIPE_REQUESTS_HIGH_WATER;
@@ -2580,18 +2580,6 @@ LLTextureFetch::~LLTextureFetch()
 		mHttpOptionsWithHeaders = NULL;
 	}
 
-	if (mHttpHeaders)
-	{
-		mHttpHeaders->release();
-		mHttpHeaders = NULL;
-	}
-
-	if (mHttpMetricsHeaders)
-	{
-		mHttpMetricsHeaders->release();
-		mHttpMetricsHeaders = NULL;
-	}
-
 	mHttpWaitResource.clear();
 	
 	delete mHttpRequest;
@@ -4162,7 +4150,7 @@ LLTextureFetchDebugger::LLTextureFetchDebugger(LLTextureFetch* fetcher, LLTextur
 	mFetcher(fetcher),
 	mTextureCache(cache),
 	mImageDecodeThread(imagedecodethread),
-	mHttpHeaders(NULL),
+	mHttpHeaders(),
 	mHttpPolicyClass(fetcher->getPolicyClass()),
 	mNbCurlCompleted(0),
 	mTempIndex(0),
@@ -4176,11 +4164,6 @@ LLTextureFetchDebugger::~LLTextureFetchDebugger()
 	mFetchingHistory.clear();
 	mStopDebug = TRUE;
 	tryToStopDebug();
-	if (mHttpHeaders)
-	{
-		mHttpHeaders->release();
-		mHttpHeaders = NULL;
-	}
 }
 
 void LLTextureFetchDebugger::init()
@@ -4225,7 +4208,7 @@ void LLTextureFetchDebugger::init()
 
 	if (! mHttpHeaders)
 	{
-		mHttpHeaders = new LLCore::HttpHeaders;
+        mHttpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders);
 		mHttpHeaders->append(HTTP_OUT_HEADER_ACCEPT, HTTP_CONTENT_IMAGE_X_J2C);
 	}
 }
diff --git a/indra/newview/lltexturefetch.h b/indra/newview/lltexturefetch.h
index 27779a31e0..a5d6cd63d7 100755
--- a/indra/newview/lltexturefetch.h
+++ b/indra/newview/lltexturefetch.h
@@ -177,7 +177,7 @@ public:
 	// to do that to hold a reference for any length of time.
 	//
 	// Threads:  T*
-	LLCore::HttpHeaders * getMetricsHeaders() const	{ return mHttpMetricsHeaders; }
+	LLCore::HttpHeaders::ptr_t getMetricsHeaders() const	{ return mHttpMetricsHeaders; }
 
 	// Threads:  T*
 	LLCore::HttpRequest::policy_t getMetricsPolicyClass() const { return mHttpMetricsPolicyClass; }
@@ -356,9 +356,9 @@ private:
 	LLCore::HttpRequest *				mHttpRequest;					// Ttf
 	LLCore::HttpOptions *				mHttpOptions;					// Ttf
 	LLCore::HttpOptions *				mHttpOptionsWithHeaders;		// Ttf
-	LLCore::HttpHeaders *				mHttpHeaders;					// Ttf
+	LLCore::HttpHeaders::ptr_t			mHttpHeaders;					// Ttf
 	LLCore::HttpRequest::policy_t		mHttpPolicyClass;				// T*
-	LLCore::HttpHeaders *				mHttpMetricsHeaders;			// Ttf
+	LLCore::HttpHeaders::ptr_t			mHttpMetricsHeaders;			// Ttf
 	LLCore::HttpRequest::policy_t		mHttpMetricsPolicyClass;		// T*
 	S32									mHttpHighWater;					// Ttf
 	S32									mHttpLowWater;					// Ttf
@@ -510,7 +510,7 @@ private:
 	LLTextureFetch* mFetcher;
 	LLTextureCache* mTextureCache;
 	LLImageDecodeThread* mImageDecodeThread;
-	LLCore::HttpHeaders* mHttpHeaders;
+	LLCore::HttpHeaders::ptr_t mHttpHeaders;
 	LLCore::HttpRequest::policy_t mHttpPolicyClass;
 	
 	S32 mNumFetchedTextures;
diff --git a/indra/newview/llviewerassetupload.cpp b/indra/newview/llviewerassetupload.cpp
index bfcdbfc109..efaf95444d 100644
--- a/indra/newview/llviewerassetupload.cpp
+++ b/indra/newview/llviewerassetupload.cpp
@@ -393,6 +393,9 @@ LLSD NewFileResourceUploadInfo::exportTempFile()
 
 }
 
+//=========================================================================
+
+
 //=========================================================================
 /*static*/
 void LLViewerAssetUpload::AssetInventoryUploadCoproc(LLCoros::self &self, LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t &httpAdapter, const LLUUID &id,
@@ -552,3 +555,4 @@ void LLViewerAssetUpload::HandleUploadError(LLCore::HttpStatus status, LLSD &res
     }
 
 }
+
diff --git a/indra/newview/llviewerassetupload.h b/indra/newview/llviewerassetupload.h
index 771828b393..a2b250b33b 100644
--- a/indra/newview/llviewerassetupload.h
+++ b/indra/newview/llviewerassetupload.h
@@ -176,6 +176,19 @@ private:
 
 };
 
+#if 0
+class NotecardResourceUploadInfo : public NewResourceUploadInfo
+{
+public:
+    NotecardResourceUploadInfo(
+        );
+
+
+protected:
+
+private:
+};
+#endif
 
 class LLViewerAssetUpload
 {
diff --git a/indra/newview/llxmlrpctransaction.cpp b/indra/newview/llxmlrpctransaction.cpp
index 066970614a..63ad4bd49b 100755
--- a/indra/newview/llxmlrpctransaction.cpp
+++ b/indra/newview/llxmlrpctransaction.cpp
@@ -390,7 +390,7 @@ void LLXMLRPCTransaction::Impl::init(XMLRPC_REQUEST request, bool useGzip)
 	mHandler = LLXMLRPCTransaction::Handler::ptr_t(new Handler( mHttpRequest, this ));
 
 	mPostH = mHttpRequest->requestPost(LLCore::HttpRequest::DEFAULT_POLICY_ID, 0, 
-		mURI, body.get(), httpOpts.get(), httpHeaders.get(), mHandler.get());
+		mURI, body.get(), httpOpts.get(), httpHeaders, mHandler.get());
 
 }
 
-- 
cgit v1.3


From fe5567639d7d4b6f13f66da0a1fb4bf2af295283 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 8 Jul 2015 12:09:36 -0700
Subject: Change HttpOptions::ptr_t to be shared_ptr<> rather than intrusive.

---
 indra/llcorehttp/_httpoprequest.cpp             | 42 ++++++++++---------------
 indra/llcorehttp/_httpoprequest.h               | 23 +++++++-------
 indra/llcorehttp/examples/http_texture_load.cpp |  6 ++--
 indra/llcorehttp/httpheaders.h                  |  2 +-
 indra/llcorehttp/httpoptions.cpp                |  2 +-
 indra/llcorehttp/httpoptions.h                  |  7 +++--
 indra/llcorehttp/httprequest.cpp                | 28 ++++++++---------
 indra/llcorehttp/httprequest.h                  | 31 +++++++++---------
 indra/llcrashlogger/llcrashlogger.cpp           |  2 +-
 indra/llmessage/llcorehttputil.cpp              | 12 +++----
 indra/llmessage/llcorehttputil.h                | 18 +++++------
 indra/newview/llinventorymodel.cpp              | 13 +++-----
 indra/newview/llinventorymodel.h                |  2 +-
 indra/newview/llmaterialmgr.cpp                 |  2 +-
 indra/newview/llmeshrepository.cpp              | 28 +++++------------
 indra/newview/llmeshrepository.h                |  6 ++--
 indra/newview/lltexturefetch.cpp                | 26 +++++----------
 indra/newview/lltexturefetch.h                  |  4 +--
 indra/newview/llxmlrpctransaction.cpp           |  2 +-
 19 files changed, 109 insertions(+), 147 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/_httpoprequest.cpp b/indra/llcorehttp/_httpoprequest.cpp
index 5d118a9afb..7baef25aca 100755
--- a/indra/llcorehttp/_httpoprequest.cpp
+++ b/indra/llcorehttp/_httpoprequest.cpp
@@ -123,7 +123,7 @@ HttpOpRequest::HttpOpRequest()
 	  mReqOffset(0),
 	  mReqLength(0),
 	  mReqHeaders(),
-	  mReqOptions(NULL),
+	  mReqOptions(),
 	  mCurlActive(false),
 	  mCurlHandle(NULL),
 	  mCurlService(NULL),
@@ -156,12 +156,6 @@ HttpOpRequest::~HttpOpRequest()
 		mReqBody = NULL;
 	}
 	
-	if (mReqOptions)
-	{
-		mReqOptions->release();
-		mReqOptions = NULL;
-	}
-
 	if (mCurlHandle)
 	{
 		// Uncertain of thread context so free using
@@ -287,8 +281,8 @@ HttpStatus HttpOpRequest::cancel()
 HttpStatus HttpOpRequest::setupGet(HttpRequest::policy_t policy_id,
 								   HttpRequest::priority_t priority,
 								   const std::string & url,
-								   HttpOptions * options,
-								   HttpHeaders::ptr_t &headers)
+                                   HttpOptions::ptr_t & options,
+								   HttpHeaders::ptr_t & headers)
 {
 	setupCommon(policy_id, priority, url, NULL, options, headers);
 	mReqMethod = HOR_GET;
@@ -302,8 +296,8 @@ HttpStatus HttpOpRequest::setupGetByteRange(HttpRequest::policy_t policy_id,
 											const std::string & url,
 											size_t offset,
 											size_t len,
-											HttpOptions * options,
-                                            HttpHeaders::ptr_t &headers)
+                                            HttpOptions::ptr_t & options,
+                                            HttpHeaders::ptr_t & headers)
 {
 	setupCommon(policy_id, priority, url, NULL, options, headers);
 	mReqMethod = HOR_GET;
@@ -322,8 +316,8 @@ HttpStatus HttpOpRequest::setupPost(HttpRequest::policy_t policy_id,
 									HttpRequest::priority_t priority,
 									const std::string & url,
 									BufferArray * body,
-									HttpOptions * options,
-                                    HttpHeaders::ptr_t &headers)
+                                    HttpOptions::ptr_t & options,
+                                    HttpHeaders::ptr_t & headers)
 {
 	setupCommon(policy_id, priority, url, body, options, headers);
 	mReqMethod = HOR_POST;
@@ -336,8 +330,8 @@ HttpStatus HttpOpRequest::setupPut(HttpRequest::policy_t policy_id,
 								   HttpRequest::priority_t priority,
 								   const std::string & url,
 								   BufferArray * body,
-								   HttpOptions * options,
-								   HttpHeaders::ptr_t &headers)
+                                   HttpOptions::ptr_t & options,
+								   HttpHeaders::ptr_t & headers)
 {
 	setupCommon(policy_id, priority, url, body, options, headers);
 	mReqMethod = HOR_PUT;
@@ -349,8 +343,8 @@ HttpStatus HttpOpRequest::setupPut(HttpRequest::policy_t policy_id,
 HttpStatus HttpOpRequest::setupDelete(HttpRequest::policy_t policy_id,
     HttpRequest::priority_t priority,
     const std::string & url,
-    HttpOptions * options,
-    HttpHeaders::ptr_t &headers)
+    HttpOptions::ptr_t & options,
+    HttpHeaders::ptr_t & headers)
 {
     setupCommon(policy_id, priority, url, NULL, options, headers);
     mReqMethod = HOR_DELETE;
@@ -363,8 +357,8 @@ HttpStatus HttpOpRequest::setupPatch(HttpRequest::policy_t policy_id,
     HttpRequest::priority_t priority,
     const std::string & url,
     BufferArray * body,
-    HttpOptions * options,
-    HttpHeaders::ptr_t &headers)
+    HttpOptions::ptr_t & options,
+    HttpHeaders::ptr_t & headers)
 {
     setupCommon(policy_id, priority, url, body, options, headers);
     mReqMethod = HOR_PATCH;
@@ -376,7 +370,7 @@ HttpStatus HttpOpRequest::setupPatch(HttpRequest::policy_t policy_id,
 HttpStatus HttpOpRequest::setupCopy(HttpRequest::policy_t policy_id,
     HttpRequest::priority_t priority,
     const std::string & url,
-    HttpOptions * options,
+    HttpOptions::ptr_t & options,
     HttpHeaders::ptr_t &headers)
 {
     setupCommon(policy_id, priority, url, NULL, options, headers);
@@ -390,8 +384,8 @@ void HttpOpRequest::setupCommon(HttpRequest::policy_t policy_id,
 								HttpRequest::priority_t priority,
 								const std::string & url,
 								BufferArray * body,
-								HttpOptions * options,
-								HttpHeaders::ptr_t &headers)
+                                HttpOptions::ptr_t & options,
+								HttpHeaders::ptr_t & headers)
 {
 	mProcFlags = 0U;
 	mReqPolicy = policy_id;
@@ -404,12 +398,10 @@ void HttpOpRequest::setupCommon(HttpRequest::policy_t policy_id,
 	}
 	if (headers && ! mReqHeaders)
 	{
-		//headers->addRef();
 		mReqHeaders = headers;
 	}
-	if (options && ! mReqOptions)
+	if (options && !mReqOptions)
 	{
-		options->addRef();
 		mReqOptions = options;
 		if (options->getWantHeaders())
 		{
diff --git a/indra/llcorehttp/_httpoprequest.h b/indra/llcorehttp/_httpoprequest.h
index 0465c2b83f..42db71e7a0 100755
--- a/indra/llcorehttp/_httpoprequest.h
+++ b/indra/llcorehttp/_httpoprequest.h
@@ -42,14 +42,13 @@
 #include "_refcounted.h"
 
 #include "httpheaders.h"
+#include "httpoptions.h"
 
 namespace LLCore
 {
 
 
 class BufferArray;
-class HttpHeaders;
-class HttpOptions;
 
 
 /// HttpOpRequest requests a supported HTTP method invocation with
@@ -105,7 +104,7 @@ public:
 	HttpStatus setupGet(HttpRequest::policy_t policy_id,
 						HttpRequest::priority_t priority,
 						const std::string & url,
-						HttpOptions * options,
+						HttpOptions::ptr_t & options,
 						HttpHeaders::ptr_t & headers);
 	
 	HttpStatus setupGetByteRange(HttpRequest::policy_t policy_id,
@@ -113,40 +112,40 @@ public:
 								 const std::string & url,
 								 size_t offset,
 								 size_t len,
-								 HttpOptions * options,
+                                 HttpOptions::ptr_t & options,
 								 HttpHeaders::ptr_t & headers);
 	
 	HttpStatus setupPost(HttpRequest::policy_t policy_id,
 						 HttpRequest::priority_t priority,
 						 const std::string & url,
 						 BufferArray * body,
-						 HttpOptions * options,
+                         HttpOptions::ptr_t & options,
 						 HttpHeaders::ptr_t & headers);
 	
 	HttpStatus setupPut(HttpRequest::policy_t policy_id,
 						HttpRequest::priority_t priority,
 						const std::string & url,
 						BufferArray * body,
-						HttpOptions * options,
+                        HttpOptions::ptr_t & options,
 						HttpHeaders::ptr_t & headers);
 
     HttpStatus setupDelete(HttpRequest::policy_t policy_id,
                         HttpRequest::priority_t priority,
                         const std::string & url,
-                        HttpOptions * options,
+                        HttpOptions::ptr_t & options,
                         HttpHeaders::ptr_t & headers);
 
     HttpStatus setupPatch(HttpRequest::policy_t policy_id,
                         HttpRequest::priority_t priority,
                         const std::string & url,
                         BufferArray * body,
-                        HttpOptions * options,
+                        HttpOptions::ptr_t & options,
                         HttpHeaders::ptr_t & headers);
 
     HttpStatus setupCopy(HttpRequest::policy_t policy_id,
                         HttpRequest::priority_t priority,
                         const std::string & url,
-                        HttpOptions * options,
+                        HttpOptions::ptr_t & options,
                         HttpHeaders::ptr_t & headers);
 
     // Internal method used to setup the libcurl options for a request.
@@ -167,8 +166,8 @@ protected:
 					 HttpRequest::priority_t priority,
 					 const std::string & url,
 					 BufferArray * body,
-					 HttpOptions * options,
-					 HttpHeaders::ptr_t &headers);
+                     HttpOptions::ptr_t & options,
+					 HttpHeaders::ptr_t & headers);
 
 	// libcurl operational callbacks
 	//
@@ -199,7 +198,7 @@ public:
 	off_t				mReqOffset;
 	size_t				mReqLength;
 	HttpHeaders::ptr_t	mReqHeaders;
-	HttpOptions *		mReqOptions;
+    HttpOptions::ptr_t  mReqOptions;
 
 	// Transport data
 	bool				mCurlActive;
diff --git a/indra/llcorehttp/examples/http_texture_load.cpp b/indra/llcorehttp/examples/http_texture_load.cpp
index 9d9631b980..13c9f90b2e 100755
--- a/indra/llcorehttp/examples/http_texture_load.cpp
+++ b/indra/llcorehttp/examples/http_texture_load.cpp
@@ -83,7 +83,7 @@ public:
 	WorkingSet();
 	~WorkingSet();
 
-	bool reload(LLCore::HttpRequest *, LLCore::HttpOptions *);
+	bool reload(LLCore::HttpRequest *, LLCore::HttpOptions::ptr_t &);
 	
 	virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);
 
@@ -304,7 +304,7 @@ int main(int argc, char** argv)
 	LLCore::HttpRequest * hr = new LLCore::HttpRequest();
 
 	// Get request options
-	LLCore::HttpOptions * opt = new LLCore::HttpOptions();
+	LLCore::HttpOptions::ptr_t opt = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions());
 	opt->setRetries(12);
 	opt->setUseRetryAfter(true);
 	
@@ -442,7 +442,7 @@ WorkingSet::~WorkingSet()
 }
 
 
-bool WorkingSet::reload(LLCore::HttpRequest * hr, LLCore::HttpOptions * opt)
+bool WorkingSet::reload(LLCore::HttpRequest * hr, LLCore::HttpOptions::ptr_t & opt)
 {
 	if (mRequestLowWater <= mHandles.size())
 	{
diff --git a/indra/llcorehttp/httpheaders.h b/indra/llcorehttp/httpheaders.h
index a97bae5537..b9168cb6ec 100755
--- a/indra/llcorehttp/httpheaders.h
+++ b/indra/llcorehttp/httpheaders.h
@@ -85,6 +85,7 @@ public:
 	typedef container_t::const_reverse_iterator const_reverse_iterator;
 	typedef container_t::value_type value_type;
 	typedef container_t::size_type size_type;
+    typedef boost::shared_ptr<HttpHeaders> ptr_t;
 
 public:
 	/// @post In addition to the instance, caller has a refcount
@@ -94,7 +95,6 @@ public:
     virtual ~HttpHeaders();						// Use release()
 
 	//typedef LLCoreInt::IntrusivePtr<HttpHeaders> ptr_t;
-    typedef boost::shared_ptr<HttpHeaders> ptr_t;
 protected:
 
 	HttpHeaders(const HttpHeaders &);			// Not defined
diff --git a/indra/llcorehttp/httpoptions.cpp b/indra/llcorehttp/httpoptions.cpp
index 3459a37aff..aab447f2dd 100755
--- a/indra/llcorehttp/httpoptions.cpp
+++ b/indra/llcorehttp/httpoptions.cpp
@@ -33,7 +33,7 @@ namespace LLCore
 {
 
 
-HttpOptions::HttpOptions() : RefCounted(true),
+HttpOptions::HttpOptions() :
     mWantHeaders(false),
     mTracing(HTTP_TRACE_OFF),
     mTimeout(HTTP_REQUEST_TIMEOUT_DEFAULT),
diff --git a/indra/llcorehttp/httpoptions.h b/indra/llcorehttp/httpoptions.h
index 2fe05a65ff..510eaa45bb 100755
--- a/indra/llcorehttp/httpoptions.h
+++ b/indra/llcorehttp/httpoptions.h
@@ -55,15 +55,16 @@ namespace LLCore
 /// Allocation:  Refcounted, heap only.  Caller of the constructor
 /// is given a refcount.
 ///
-class HttpOptions : public LLCoreInt::RefCounted
+class HttpOptions : private boost::noncopyable
 {
 public:
 	HttpOptions();
 
-	typedef LLCoreInt::IntrusivePtr<HttpOptions> ptr_t;
+	typedef boost::shared_ptr<HttpOptions> ptr_t;
+
+    virtual ~HttpOptions();						// Use release()
 
 protected:
-	virtual ~HttpOptions();						// Use release()
 	
 	HttpOptions(const HttpOptions &);			// Not defined
 	void operator=(const HttpOptions &);		// Not defined
diff --git a/indra/llcorehttp/httprequest.cpp b/indra/llcorehttp/httprequest.cpp
index b5ea0b44b0..4a7352c962 100755
--- a/indra/llcorehttp/httprequest.cpp
+++ b/indra/llcorehttp/httprequest.cpp
@@ -197,8 +197,8 @@ HttpStatus HttpRequest::getStatus() const
 HttpHandle HttpRequest::requestGet(policy_t policy_id,
 								   priority_t priority,
 								   const std::string & url,
-								   HttpOptions * options,
-								   HttpHeaders::ptr_t &headers,
+                                   HttpOptions::ptr_t & options,
+								   HttpHeaders::ptr_t & headers,
 								   HttpHandler * user_handler)
 {
 	HttpStatus status;
@@ -231,8 +231,8 @@ HttpHandle HttpRequest::requestGetByteRange(policy_t policy_id,
 											const std::string & url,
 											size_t offset,
 											size_t len,
-											HttpOptions * options,
-											HttpHeaders::ptr_t &headers,
+                                            HttpOptions::ptr_t & options,
+											HttpHeaders::ptr_t & headers,
 											HttpHandler * user_handler)
 {
 	HttpStatus status;
@@ -264,8 +264,8 @@ HttpHandle HttpRequest::requestPost(policy_t policy_id,
 									priority_t priority,
 									const std::string & url,
 									BufferArray * body,
-									HttpOptions * options,
-									HttpHeaders::ptr_t &headers,
+                                    HttpOptions::ptr_t & options,
+									HttpHeaders::ptr_t & headers,
 									HttpHandler * user_handler)
 {
 	HttpStatus status;
@@ -297,8 +297,8 @@ HttpHandle HttpRequest::requestPut(policy_t policy_id,
 								   priority_t priority,
 								   const std::string & url,
 								   BufferArray * body,
-								   HttpOptions * options,
-								   HttpHeaders::ptr_t &headers,
+                                   HttpOptions::ptr_t & options,
+								   HttpHeaders::ptr_t & headers,
 								   HttpHandler * user_handler)
 {
 	HttpStatus status;
@@ -328,8 +328,8 @@ HttpHandle HttpRequest::requestPut(policy_t policy_id,
 HttpHandle HttpRequest::requestDelete(policy_t policy_id,
     priority_t priority,
     const std::string & url,
-    HttpOptions * options,
-    HttpHeaders::ptr_t &headers,
+    HttpOptions::ptr_t & options,
+    HttpHeaders::ptr_t & headers,
     HttpHandler * user_handler)
 {
     HttpStatus status;
@@ -360,8 +360,8 @@ HttpHandle HttpRequest::requestPatch(policy_t policy_id,
     priority_t priority,
     const std::string & url,
     BufferArray * body,
-    HttpOptions * options,
-    HttpHeaders::ptr_t &headers,
+    HttpOptions::ptr_t & options,
+    HttpHeaders::ptr_t & headers,
     HttpHandler * user_handler)
 {
     HttpStatus status;
@@ -391,8 +391,8 @@ HttpHandle HttpRequest::requestPatch(policy_t policy_id,
 HttpHandle HttpRequest::requestCopy(policy_t policy_id,
     priority_t priority,
     const std::string & url,
-    HttpOptions * options,
-    HttpHeaders::ptr_t &headers,
+    HttpOptions::ptr_t & options,
+    HttpHeaders::ptr_t & headers,
     HttpHandler * user_handler)
 {
     HttpStatus status;
diff --git a/indra/llcorehttp/httprequest.h b/indra/llcorehttp/httprequest.h
index c0622372e1..58aea1444c 100755
--- a/indra/llcorehttp/httprequest.h
+++ b/indra/llcorehttp/httprequest.h
@@ -32,6 +32,7 @@
 #include "httphandler.h"
 
 #include "httpheaders.h"
+#include "httpoptions.h"
 
 namespace LLCore
 {
@@ -39,8 +40,6 @@ namespace LLCore
 class HttpRequestQueue;
 class HttpReplyQueue;
 class HttpService;
-class HttpOptions;
-class HttpHeaders;
 class HttpOperation;
 class BufferArray;
 
@@ -349,8 +348,8 @@ public:
 	HttpHandle requestGet(policy_t policy_id,
 						  priority_t priority,
 						  const std::string & url,
-						  HttpOptions * options,
-						  HttpHeaders::ptr_t &headers,
+                          HttpOptions::ptr_t & options,
+						  HttpHeaders::ptr_t & headers,
 						  HttpHandler * handler);
 
 
@@ -392,8 +391,8 @@ public:
 								   const std::string & url,
 								   size_t offset,
 								   size_t len,
-								   HttpOptions * options,
-								   HttpHeaders::ptr_t &headers,
+                                   HttpOptions::ptr_t & options,
+								   HttpHeaders::ptr_t & headers,
 								   HttpHandler * handler);
 
 
@@ -433,8 +432,8 @@ public:
 						   priority_t priority,
 						   const std::string & url,
 						   BufferArray * body,
-						   HttpOptions * options,
-						   HttpHeaders::ptr_t &headers,
+                           HttpOptions::ptr_t & options,
+						   HttpHeaders::ptr_t & headers,
 						   HttpHandler * handler);
 
 
@@ -474,8 +473,8 @@ public:
 						  priority_t priority,
 						  const std::string & url,
 						  BufferArray * body,
-						  HttpOptions * options,
-						  HttpHeaders::ptr_t &headers,
+                          HttpOptions::ptr_t & options,
+						  HttpHeaders::ptr_t & headers,
 						  HttpHandler * handler);
 
 
@@ -494,8 +493,8 @@ public:
     HttpHandle requestDelete(policy_t policy_id,
             priority_t priority,
             const std::string & url,
-            HttpOptions * options,
-            HttpHeaders::ptr_t &headers,
+            HttpOptions::ptr_t & options,
+            HttpHeaders::ptr_t & headers,
             HttpHandler * user_handler);
 
     /// Queue a full HTTP PUT.  Query arguments and body may
@@ -517,8 +516,8 @@ public:
             priority_t priority,
             const std::string & url,
             BufferArray * body,
-            HttpOptions * options,
-            HttpHeaders::ptr_t &headers,
+            HttpOptions::ptr_t & options,
+            HttpHeaders::ptr_t & headers,
             HttpHandler * user_handler);
 
     /// Queue a full HTTP PUT.  Query arguments and body may
@@ -536,8 +535,8 @@ public:
     HttpHandle requestCopy(policy_t policy_id,
             priority_t priority,
             const std::string & url,
-            HttpOptions * options,
-            HttpHeaders::ptr_t &headers,
+            HttpOptions::ptr_t & options,
+            HttpHeaders::ptr_t & headers,
             HttpHandler * user_handler);
        
     /// Queue a NoOp request.
diff --git a/indra/llcrashlogger/llcrashlogger.cpp b/indra/llcrashlogger/llcrashlogger.cpp
index ed585ff64e..4caf6dcd05 100755
--- a/indra/llcrashlogger/llcrashlogger.cpp
+++ b/indra/llcrashlogger/llcrashlogger.cpp
@@ -407,7 +407,7 @@ bool LLCrashLogger::runCrashLogPost(std::string host, LLSD data, std::string msg
 		updateApplication(llformat("%s, try %d...", msg.c_str(), i+1));
 
         LLCoreHttpUtil::requestPostWithLLSD(httpRequest.get(), LLCore::HttpRequest::DEFAULT_POLICY_ID, 0,
-            host, data, httpOpts.get(), LLCore::HttpHeaders::ptr_t(), new LLCrashLoggerHandler);
+            host, data, httpOpts, LLCore::HttpHeaders::ptr_t(), new LLCrashLoggerHandler);
 
         while(!gBreak)
 		{
diff --git a/indra/llmessage/llcorehttputil.cpp b/indra/llmessage/llcorehttputil.cpp
index e3588b74ee..24f5d77ee1 100644
--- a/indra/llmessage/llcorehttputil.cpp
+++ b/indra/llmessage/llcorehttputil.cpp
@@ -102,7 +102,7 @@ HttpHandle requestPostWithLLSD(HttpRequest * request,
     HttpRequest::priority_t priority,
     const std::string & url,
     const LLSD & body,
-    HttpOptions * options,
+    HttpOptions::ptr_t &options,
     HttpHeaders::ptr_t &headers,
     HttpHandler * handler)
 {
@@ -129,7 +129,7 @@ HttpHandle requestPutWithLLSD(HttpRequest * request,
     HttpRequest::priority_t priority,
     const std::string & url,
     const LLSD & body,
-    HttpOptions * options,
+    HttpOptions::ptr_t &options,
     HttpHeaders::ptr_t &headers,
     HttpHandler * handler)
 {
@@ -155,7 +155,7 @@ HttpHandle requestPatchWithLLSD(HttpRequest * request,
     HttpRequest::priority_t priority,
     const std::string & url,
     const LLSD & body,
-    HttpOptions * options,
+    HttpOptions::ptr_t &options,
     HttpHeaders::ptr_t &headers,
     HttpHandler * handler)
 {
@@ -689,7 +689,7 @@ LLSD HttpCoroutineAdapter::postAndYield_(LLCoros::self & self, LLCore::HttpReque
     // 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->requestPost(mPolicyId, mPriority, url, rawbody.get(),
-        options.get(), headers, handler.get());
+        options, headers, handler.get());
 
     if (hhandle == LLCORE_HTTP_HANDLE_INVALID)
     {
@@ -782,7 +782,7 @@ LLSD HttpCoroutineAdapter::getAndYield_(LLCoros::self & self, LLCore::HttpReques
     // 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->requestGet(mPolicyId, mPriority,
-        url, options.get(), headers, handler.get());
+        url, options, headers, handler.get());
 
     if (hhandle == LLCORE_HTTP_HANDLE_INVALID)
     {
@@ -817,7 +817,7 @@ LLSD HttpCoroutineAdapter::deleteAndYield_(LLCoros::self & self, LLCore::HttpReq
     // 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->requestDelete(mPolicyId, mPriority,
-        url, options.get(), headers, handler.get());
+        url, options, headers, handler.get());
 
     if (hhandle == LLCORE_HTTP_HANDLE_INVALID)
     {
diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index a54f94e6f0..1e575e0e0c 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -111,7 +111,7 @@ LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest * request,
 									   LLCore::HttpRequest::priority_t priority,
 									   const std::string & url,
 									   const LLSD & body,
-									   LLCore::HttpOptions * options,
+                                       LLCore::HttpOptions::ptr_t &options,
 									   LLCore::HttpHeaders::ptr_t &headers,
 									   LLCore::HttpHandler * handler);
 
@@ -125,7 +125,7 @@ inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & reque
 	LLCore::HttpHandler * handler)
 {
     return requestPostWithLLSD(request.get(), policy_id, priority,
-        url, body, options.get(), headers, handler);
+        url, body, options, headers, handler);
 }
 
 inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -136,7 +136,7 @@ inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & reque
     LLCore::HttpHandler * handler)
 {
     return requestPostWithLLSD(request.get(), policy_id, priority,
-        url, body, NULL, LLCore::HttpHeaders::ptr_t(), handler);
+        url, body, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t(), handler);
 }
 
 
@@ -161,7 +161,7 @@ LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest * request,
 	LLCore::HttpRequest::priority_t priority,
 	const std::string & url,
 	const LLSD & body,
-	LLCore::HttpOptions * options,
+	LLCore::HttpOptions::ptr_t &options,
 	LLCore::HttpHeaders::ptr_t &headers,
 	LLCore::HttpHandler * handler);
 
@@ -175,7 +175,7 @@ inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & reques
 	LLCore::HttpHandler * handler)
 {
     return requestPutWithLLSD(request.get(), policy_id, priority,
-        url, body, options.get(), headers, handler);
+        url, body, options, headers, handler);
 }
 
 inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -186,7 +186,7 @@ inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & reques
     LLCore::HttpHandler * handler)
 {
     return requestPutWithLLSD(request.get(), policy_id, priority,
-        url, body, NULL, LLCore::HttpHeaders::ptr_t(), handler);
+        url, body, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t(), handler);
 }
 
 /// Issue a standard HttpRequest::requestPatch() call but using
@@ -210,7 +210,7 @@ LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest * request,
     LLCore::HttpRequest::priority_t priority,
     const std::string & url,
     const LLSD & body,
-    LLCore::HttpOptions * options,
+    LLCore::HttpOptions::ptr_t &options,
     LLCore::HttpHeaders::ptr_t &headers,
     LLCore::HttpHandler * handler);
 
@@ -224,7 +224,7 @@ inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & requ
     LLCore::HttpHandler * handler)
 {
     return requestPatchWithLLSD(request.get(), policy_id, priority,
-        url, body, options.get(), headers, handler);
+        url, body, options, headers, handler);
 }
 
 inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -235,7 +235,7 @@ inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & requ
     LLCore::HttpHandler * handler)
 {
     return requestPatchWithLLSD(request.get(), policy_id, priority,
-        url, body, NULL, LLCore::HttpHeaders::ptr_t(), handler);
+        url, body, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t(), handler);
 }
 
 //=========================================================================
diff --git a/indra/newview/llinventorymodel.cpp b/indra/newview/llinventorymodel.cpp
index cf550c20c5..39aeab22e5 100755
--- a/indra/newview/llinventorymodel.cpp
+++ b/indra/newview/llinventorymodel.cpp
@@ -148,7 +148,7 @@ LLInventoryModel::LLInventoryModel()
 	mObservers(),
 	mHttpRequestFG(NULL),
 	mHttpRequestBG(NULL),
-	mHttpOptions(NULL),
+	mHttpOptions(),
 	mHttpHeaders(),
 	mHttpPolicyClass(LLCore::HttpRequest::DEFAULT_POLICY_ID),
 	mHttpPriorityFG(0),
@@ -179,11 +179,8 @@ void LLInventoryModel::cleanupInventory()
 
 	// Run down HTTP transport
     mHttpHeaders.reset();
-	if (mHttpOptions)
-	{
-		mHttpOptions->release();
-		mHttpOptions = NULL;
-	}
+    mHttpOptions.reset();
+
 	delete mHttpRequestFG;
 	mHttpRequestFG = NULL;
 	delete mHttpRequestBG;
@@ -609,7 +606,7 @@ void LLInventoryModel::createNewCategoryCoro(LLCoros::self& self, std::string ur
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("createNewCategoryCoro", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
     
 
     httpOpts->setWantHeaders(true);
@@ -2414,7 +2411,7 @@ void LLInventoryModel::initHttpRequest()
 
 		mHttpRequestFG = new LLCore::HttpRequest;
 		mHttpRequestBG = new LLCore::HttpRequest;
-		mHttpOptions = new LLCore::HttpOptions;
+		mHttpOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions);
 		mHttpOptions->setTransferTimeout(300);
 		mHttpOptions->setUseRetryAfter(true);
 		// mHttpOptions->setTrace(2);		// Do tracing of requests
diff --git a/indra/newview/llinventorymodel.h b/indra/newview/llinventorymodel.h
index 9711fb95f6..f768e61ccb 100755
--- a/indra/newview/llinventorymodel.h
+++ b/indra/newview/llinventorymodel.h
@@ -571,7 +571,7 @@ private:
 	// Usual plumbing for LLCore:: HTTP operations.
 	LLCore::HttpRequest *				mHttpRequestFG;
 	LLCore::HttpRequest *				mHttpRequestBG;
-	LLCore::HttpOptions *				mHttpOptions;
+	LLCore::HttpOptions::ptr_t			mHttpOptions;
 	LLCore::HttpHeaders::ptr_t			mHttpHeaders;
 	LLCore::HttpRequest::policy_t		mHttpPolicyClass;
 	LLCore::HttpRequest::priority_t		mHttpPriorityFG;
diff --git a/indra/newview/llmaterialmgr.cpp b/indra/newview/llmaterialmgr.cpp
index e6f3540877..1045def72e 100755
--- a/indra/newview/llmaterialmgr.cpp
+++ b/indra/newview/llmaterialmgr.cpp
@@ -712,7 +712,7 @@ void LLMaterialMgr::processGetAllQueue()
 			);
 
 		LLCore::HttpHandle handle = mHttpRequest->requestGet(mHttpPolicy, mHttpPriority, capURL,
-				mHttpOptions.get(), mHttpHeaders, handler);
+				mHttpOptions, mHttpHeaders, handler);
 
 		if (handle == LLCORE_HTTP_HANDLE_INVALID)
 		{
diff --git a/indra/newview/llmeshrepository.cpp b/indra/newview/llmeshrepository.cpp
index 7f8e357e33..d6aaf18cb7 100755
--- a/indra/newview/llmeshrepository.cpp
+++ b/indra/newview/llmeshrepository.cpp
@@ -738,8 +738,8 @@ void log_upload_error(LLCore::HttpStatus status, const LLSD& content,
 LLMeshRepoThread::LLMeshRepoThread()
 : LLThread("mesh repo"),
   mHttpRequest(NULL),
-  mHttpOptions(NULL),
-  mHttpLargeOptions(NULL),
+  mHttpOptions(),
+  mHttpLargeOptions(),
   mHttpHeaders(),
   mHttpPolicyClass(LLCore::HttpRequest::DEFAULT_POLICY_ID),
   mHttpLegacyPolicyClass(LLCore::HttpRequest::DEFAULT_POLICY_ID),
@@ -753,10 +753,10 @@ LLMeshRepoThread::LLMeshRepoThread()
 	mHeaderMutex = new LLMutex(NULL);
 	mSignal = new LLCondition(NULL);
 	mHttpRequest = new LLCore::HttpRequest;
-	mHttpOptions = new LLCore::HttpOptions;
+	mHttpOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions);
 	mHttpOptions->setTransferTimeout(SMALL_MESH_XFER_TIMEOUT);
 	mHttpOptions->setUseRetryAfter(gSavedSettings.getBOOL("MeshUseHttpRetryAfter"));
-	mHttpLargeOptions = new LLCore::HttpOptions;
+	mHttpLargeOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions);
 	mHttpLargeOptions->setTransferTimeout(LARGE_MESH_XFER_TIMEOUT);
 	mHttpLargeOptions->setUseRetryAfter(gSavedSettings.getBOOL("MeshUseHttpRetryAfter"));
 	mHttpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders);
@@ -782,17 +782,8 @@ LLMeshRepoThread::~LLMeshRepoThread()
 	}
 	mHttpRequestSet.clear();
     mHttpHeaders.reset();
-	if (mHttpOptions)
-	{
-		mHttpOptions->release();
-		mHttpOptions = NULL;
-	}
-	if (mHttpLargeOptions)
-	{
-		mHttpLargeOptions->release();
-		mHttpLargeOptions = NULL;
-	}
-	delete mHttpRequest;
+
+    delete mHttpRequest;
 	mHttpRequest = NULL;
 	delete mMutex;
 	mMutex = NULL;
@@ -1878,7 +1869,7 @@ LLMeshUploadThread::LLMeshUploadThread(LLMeshUploadThread::instance_list& data,
 	mMeshUploadTimeOut = gSavedSettings.getS32("MeshUploadTimeOut") ;
 
 	mHttpRequest = new LLCore::HttpRequest;
-	mHttpOptions = new LLCore::HttpOptions;
+	mHttpOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions);
 	mHttpOptions->setTransferTimeout(mMeshUploadTimeOut);
 	mHttpOptions->setUseRetryAfter(gSavedSettings.getBOOL("MeshUseHttpRetryAfter"));
 	mHttpOptions->setRetries(UPLOAD_RETRY_LIMIT);
@@ -1890,11 +1881,6 @@ LLMeshUploadThread::LLMeshUploadThread(LLMeshUploadThread::instance_list& data,
 
 LLMeshUploadThread::~LLMeshUploadThread()
 {
-	if (mHttpOptions)
-	{
-		mHttpOptions->release();
-		mHttpOptions = NULL;
-	}
 	delete mHttpRequest;
 	mHttpRequest = NULL;
 }
diff --git a/indra/newview/llmeshrepository.h b/indra/newview/llmeshrepository.h
index dc1fa883b3..55157cc040 100755
--- a/indra/newview/llmeshrepository.h
+++ b/indra/newview/llmeshrepository.h
@@ -322,8 +322,8 @@ public:
 	// llcorehttp library interface objects.
 	LLCore::HttpStatus					mHttpStatus;
 	LLCore::HttpRequest *				mHttpRequest;
-	LLCore::HttpOptions *				mHttpOptions;
-	LLCore::HttpOptions *				mHttpLargeOptions;
+	LLCore::HttpOptions::ptr_t			mHttpOptions;
+	LLCore::HttpOptions::ptr_t			mHttpLargeOptions;
 	LLCore::HttpHeaders::ptr_t			mHttpHeaders;
 	LLCore::HttpRequest::policy_t		mHttpPolicyClass;
 	LLCore::HttpRequest::policy_t		mHttpLegacyPolicyClass;
@@ -493,7 +493,7 @@ private:
 	// llcorehttp library interface objects.
 	LLCore::HttpStatus					mHttpStatus;
 	LLCore::HttpRequest *				mHttpRequest;
-	LLCore::HttpOptions *				mHttpOptions;
+	LLCore::HttpOptions::ptr_t			mHttpOptions;
 	LLCore::HttpHeaders::ptr_t			mHttpHeaders;
 	LLCore::HttpRequest::policy_t		mHttpPolicyClass;
 	LLCore::HttpRequest::priority_t		mHttpPriority;
diff --git a/indra/newview/lltexturefetch.cpp b/indra/newview/lltexturefetch.cpp
index 1055216b65..e61eeb2f4e 100755
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
@@ -1557,7 +1557,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 
 		// Will call callbackHttpGet when curl request completes
 		// Only server bake images use the returned headers currently, for getting retry-after field.
-		LLCore::HttpOptions *options = (mFTType == FTT_SERVER_BAKE) ? mFetcher->mHttpOptionsWithHeaders: mFetcher->mHttpOptions;
+		LLCore::HttpOptions::ptr_t options = (mFTType == FTT_SERVER_BAKE) ? mFetcher->mHttpOptionsWithHeaders: mFetcher->mHttpOptions;
 		if (disable_range_req)
 		{
 			// 'Range:' requests may be disabled in which case all HTTP
@@ -2509,8 +2509,8 @@ LLTextureFetch::LLTextureFetch(LLTextureCache* cache, LLImageDecodeThread* image
 	  mTotalHTTPRequests(0),
 	  mQAMode(qa_mode),
 	  mHttpRequest(NULL),
-	  mHttpOptions(NULL),
-	  mHttpOptionsWithHeaders(NULL),
+	  mHttpOptions(),
+	  mHttpOptionsWithHeaders(),
 	  mHttpHeaders(),
 	  mHttpPolicyClass(LLCore::HttpRequest::DEFAULT_POLICY_ID),
 	  mHttpMetricsHeaders(),
@@ -2528,8 +2528,8 @@ LLTextureFetch::LLTextureFetch(LLTextureCache* cache, LLImageDecodeThread* image
 
 	LLAppCoreHttp & app_core_http(LLAppViewer::instance()->getAppCoreHttp());
 	mHttpRequest = new LLCore::HttpRequest;
-	mHttpOptions = new LLCore::HttpOptions;
-	mHttpOptionsWithHeaders = new LLCore::HttpOptions;
+	mHttpOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions);
+	mHttpOptionsWithHeaders = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions);
 	mHttpOptionsWithHeaders->setWantHeaders(true);
     mHttpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders);
 	mHttpHeaders->append(HTTP_OUT_HEADER_ACCEPT, HTTP_CONTENT_IMAGE_X_J2C);
@@ -2568,18 +2568,6 @@ LLTextureFetch::~LLTextureFetch()
 		delete req;
 	}
 
-	if (mHttpOptions)
-	{
-		mHttpOptions->release();
-		mHttpOptions = NULL;
-	}
-
-	if (mHttpOptionsWithHeaders)
-	{
-		mHttpOptionsWithHeaders->release();
-		mHttpOptionsWithHeaders = NULL;
-	}
-
 	mHttpWaitResource.clear();
 	
 	delete mHttpRequest;
@@ -4031,7 +4019,7 @@ TFReqSendMetrics::doWork(LLTextureFetch * fetcher)
 											report_priority,
 											mCapsURL,
 											sd,
-											NULL,
+											LLCore::HttpOptions::ptr_t(),
 											fetcher->getMetricsHeaders(),
 											handler);
 		LLTextureFetch::svMetricsDataBreak = false;
@@ -4608,7 +4596,7 @@ S32 LLTextureFetchDebugger::fillCurlQueue()
 																				   texture_url,
 																				   0,
 																				   requestedSize,
-																				   NULL,
+																				   LLCore::HttpOptions::ptr_t(),
 																				   mHttpHeaders,
 																				   this);
 		if (LLCORE_HTTP_HANDLE_INVALID != handle)
diff --git a/indra/newview/lltexturefetch.h b/indra/newview/lltexturefetch.h
index a5d6cd63d7..e569175e8f 100755
--- a/indra/newview/lltexturefetch.h
+++ b/indra/newview/lltexturefetch.h
@@ -354,8 +354,8 @@ private:
 	// to make our HTTP requests.  These replace the various
 	// LLCurl interfaces used in the past.
 	LLCore::HttpRequest *				mHttpRequest;					// Ttf
-	LLCore::HttpOptions *				mHttpOptions;					// Ttf
-	LLCore::HttpOptions *				mHttpOptionsWithHeaders;		// Ttf
+	LLCore::HttpOptions::ptr_t			mHttpOptions;					// Ttf
+	LLCore::HttpOptions::ptr_t			mHttpOptionsWithHeaders;		// Ttf
 	LLCore::HttpHeaders::ptr_t			mHttpHeaders;					// Ttf
 	LLCore::HttpRequest::policy_t		mHttpPolicyClass;				// T*
 	LLCore::HttpHeaders::ptr_t			mHttpMetricsHeaders;			// Ttf
diff --git a/indra/newview/llxmlrpctransaction.cpp b/indra/newview/llxmlrpctransaction.cpp
index 63ad4bd49b..5828aee7fc 100755
--- a/indra/newview/llxmlrpctransaction.cpp
+++ b/indra/newview/llxmlrpctransaction.cpp
@@ -390,7 +390,7 @@ void LLXMLRPCTransaction::Impl::init(XMLRPC_REQUEST request, bool useGzip)
 	mHandler = LLXMLRPCTransaction::Handler::ptr_t(new Handler( mHttpRequest, this ));
 
 	mPostH = mHttpRequest->requestPost(LLCore::HttpRequest::DEFAULT_POLICY_ID, 0, 
-		mURI, body.get(), httpOpts.get(), httpHeaders, mHandler.get());
+		mURI, body.get(), httpOpts, httpHeaders, mHandler.get());
 
 }
 
-- 
cgit v1.3


From 7ff38e34eaea52b4d1b856efa9de685cbdbd28ba Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 8 Jul 2015 12:44:57 -0700
Subject: Update the unit tests to use the new pointer type.

---
 indra/llcorehttp/tests/test_httpheaders.hpp    |  27 +-
 indra/llcorehttp/tests/test_httprequest.hpp    | 328 ++++++++-----------------
 indra/newview/tests/llhttpretrypolicy_test.cpp |   6 +-
 3 files changed, 119 insertions(+), 242 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/tests/test_httpheaders.hpp b/indra/llcorehttp/tests/test_httpheaders.hpp
index 668c36dc66..c05f1d9429 100755
--- a/indra/llcorehttp/tests/test_httpheaders.hpp
+++ b/indra/llcorehttp/tests/test_httpheaders.hpp
@@ -59,13 +59,12 @@ void HttpHeadersTestObjectType::test<1>()
 	mMemTotal = GetMemTotal();
 
 	// create a new ref counted object with an implicit reference
-	HttpHeaders * headers = new HttpHeaders();
-	ensure("One ref on construction of HttpHeaders", headers->getRefCount() == 1);
+	HttpHeaders::ptr_t headers = HttpHeaders::ptr_t(new HttpHeaders());
 	ensure("Memory being used", mMemTotal < GetMemTotal());
 	ensure("Nothing in headers", 0 == headers->size());
 
 	// release the implicit reference, causing the object to be released
-	headers->release();
+    headers.reset();
 
 	// make sure we didn't leak any memory
 	ensure(mMemTotal == GetMemTotal());
@@ -80,7 +79,7 @@ void HttpHeadersTestObjectType::test<2>()
 	mMemTotal = GetMemTotal();
 
 	// create a new ref counted object with an implicit reference
-	HttpHeaders * headers = new HttpHeaders();
+	HttpHeaders::ptr_t headers = HttpHeaders::ptr_t(new HttpHeaders());
 	
 	{
 		// Append a few strings
@@ -101,7 +100,7 @@ void HttpHeadersTestObjectType::test<2>()
 	}
 	
 	// release the implicit reference, causing the object to be released
-	headers->release();
+    headers.reset();
 
 	// make sure we didn't leak any memory
 	ensure(mMemTotal == GetMemTotal());
@@ -116,7 +115,7 @@ void HttpHeadersTestObjectType::test<3>()
 	mMemTotal = GetMemTotal();
 
 	// create a new ref counted object with an implicit reference
-	HttpHeaders * headers = new HttpHeaders();
+	HttpHeaders::ptr_t headers = HttpHeaders::ptr_t(new HttpHeaders());
 	
 	{
 		// Append a few strings
@@ -151,7 +150,7 @@ void HttpHeadersTestObjectType::test<3>()
 	}
 	
 	// release the implicit reference, causing the object to be released
-	headers->release();
+    headers.reset();
 
 	// make sure we didn't leak any memory
 	ensure(mMemTotal == GetMemTotal());
@@ -166,8 +165,8 @@ void HttpHeadersTestObjectType::test<4>()
 	mMemTotal = GetMemTotal();
 
 	// create a new ref counted object with an implicit reference
-	HttpHeaders * headers = new HttpHeaders();
-	
+    HttpHeaders::ptr_t headers = HttpHeaders::ptr_t(new HttpHeaders());
+
 	{
 		static char line1[] = " AcCePT : image/yourfacehere";
 		static char line1v[] = "image/yourfacehere";
@@ -251,7 +250,7 @@ void HttpHeadersTestObjectType::test<4>()
 	}
 	
 	// release the implicit reference, causing the object to be released
-	headers->release();
+    headers.reset();
 
 	// make sure we didn't leak any memory
 	ensure(mMemTotal == GetMemTotal());
@@ -267,7 +266,7 @@ void HttpHeadersTestObjectType::test<5>()
 	mMemTotal = GetMemTotal();
 
 	// create a new ref counted object with an implicit reference
-	HttpHeaders * headers = new HttpHeaders();
+    HttpHeaders::ptr_t headers = HttpHeaders::ptr_t(new HttpHeaders());
 
 	HttpHeaders::iterator end(headers->end()), begin(headers->begin());
 	ensure("Empty container has equal begin/end const iterators", end == begin);
@@ -337,7 +336,7 @@ void HttpHeadersTestObjectType::test<5>()
 	}
 	
 	// release the implicit reference, causing the object to be released
-	headers->release();
+    headers.reset();
 
 	// make sure we didn't leak any memory
 	ensure(mMemTotal == GetMemTotal());
@@ -353,7 +352,7 @@ void HttpHeadersTestObjectType::test<6>()
 	mMemTotal = GetMemTotal();
 
 	// create a new ref counted object with an implicit reference
-	HttpHeaders * headers = new HttpHeaders();
+    HttpHeaders::ptr_t headers = HttpHeaders::ptr_t(new HttpHeaders());
 
 	HttpHeaders::reverse_iterator rend(headers->rend()), rbegin(headers->rbegin());
 	ensure("Empty container has equal rbegin/rend const iterators", rend == rbegin);
@@ -421,7 +420,7 @@ void HttpHeadersTestObjectType::test<6>()
 	}
 	
 	// release the implicit reference, causing the object to be released
-	headers->release();
+    headers.reset();
 
 	// make sure we didn't leak any memory
 	ensure(mMemTotal == GetMemTotal());
diff --git a/indra/llcorehttp/tests/test_httprequest.hpp b/indra/llcorehttp/tests/test_httprequest.hpp
index 43f7e36da5..1f606bd0c1 100755
--- a/indra/llcorehttp/tests/test_httprequest.hpp
+++ b/indra/llcorehttp/tests/test_httprequest.hpp
@@ -112,7 +112,7 @@ public:
 			if (! mHeadersRequired.empty() || ! mHeadersDisallowed.empty())
 			{
 				ensure("Response required with header check", response != NULL);
-				HttpHeaders * header(response->getHeaders());	// Will not hold onto this
+				HttpHeaders::ptr_t header(response->getHeaders());	// Will not hold onto this
 				ensure("Some quantity of headers returned", header != NULL);
 
 				if (! mHeadersRequired.empty())
@@ -638,7 +638,7 @@ void HttpRequestTestObjectType::test<7>()
 	mHandlerCalls = 0;
 
 	HttpRequest * req = NULL;
-	HttpOptions * opts = NULL;
+	HttpOptions::ptr_t opts;
 	
 	try
 	{
@@ -653,7 +653,7 @@ void HttpRequestTestObjectType::test<7>()
 		req = new HttpRequest();
 		ensure("Memory allocated on construction", mMemTotal < GetMemTotal());
 
-		opts = new HttpOptions();
+        opts = HttpOptions::ptr_t(new HttpOptions());
 		opts->setRetries(1);			// Don't try for too long - default retries take about 18S
 		
 		// Issue a GET that can't connect
@@ -664,7 +664,7 @@ void HttpRequestTestObjectType::test<7>()
 													 0,
 													 0,
 													 opts,
-													 NULL,
+													 HttpHeaders::ptr_t(),
 													 &handler);
 		ensure("Valid handle returned for ranged request", handle != LLCORE_HTTP_HANDLE_INVALID);
 
@@ -705,8 +705,7 @@ void HttpRequestTestObjectType::test<7>()
 		ensure("Thread actually stopped running", HttpService::isStopped());
 
 		// release options
-		opts->release();
-		opts = NULL;
+        opts.reset();
 		
 		// release the request object
 		delete req;
@@ -728,11 +727,7 @@ void HttpRequestTestObjectType::test<7>()
 	catch (...)
 	{
 		stop_thread(req);
-		if (opts)
-		{
-			opts->release();
-			opts = NULL;
-		}
+        opts.reset();
 		delete req;
 		HttpRequest::destroyService();
 		throw;
@@ -779,8 +774,8 @@ void HttpRequestTestObjectType::test<8>()
 		HttpHandle handle = req->requestGet(HttpRequest::DEFAULT_POLICY_ID,
 											0U,
 											url_base,
-											NULL,
-											NULL,
+											HttpOptions::ptr_t(),
+                                            HttpHeaders::ptr_t(),
 											&handler);
 		ensure("Valid handle returned for ranged request", handle != LLCORE_HTTP_HANDLE_INVALID);
 
@@ -889,8 +884,8 @@ void HttpRequestTestObjectType::test<9>()
 													 url_base,
 													 0,
 													 0,
-													 NULL,
-													 NULL,
+													 HttpOptions::ptr_t(),
+                                                     HttpHeaders::ptr_t(),
 													 &handler);
 		ensure("Valid handle returned for ranged request", handle != LLCORE_HTTP_HANDLE_INVALID);
 
@@ -1001,9 +996,9 @@ void HttpRequestTestObjectType::test<10>()
 											0U,
 											url_base,
 											body,
-											NULL,
-											NULL,
-											&handler);
+                                            HttpOptions::ptr_t(),
+                                            HttpHeaders::ptr_t(),
+                                            &handler);
 		ensure("Valid handle returned for ranged request", handle != LLCORE_HTTP_HANDLE_INVALID);
 
 		// Run the notification pump.
@@ -1119,9 +1114,9 @@ void HttpRequestTestObjectType::test<11>()
 											 0U,
 											 url_base,
 											 body,
-											 NULL,
-											 NULL,
-											 &handler);
+                                             HttpOptions::ptr_t(),
+                                             HttpHeaders::ptr_t(),
+                                             &handler);
 		ensure("Valid handle returned for ranged request", handle != LLCORE_HTTP_HANDLE_INVALID);
 
 		// Run the notification pump.
@@ -1239,9 +1234,9 @@ void HttpRequestTestObjectType::test<12>()
 													 url_base,
 													 0,
 													 0,
-													 NULL,
-													 NULL,
-													 &handler);
+                                                     HttpOptions::ptr_t(),
+                                                     HttpHeaders::ptr_t(),
+                                                     &handler);
 		ensure("Valid handle returned for ranged request", handle != LLCORE_HTTP_HANDLE_INVALID);
 
 		// Run the notification pump.
@@ -1332,7 +1327,7 @@ void HttpRequestTestObjectType::test<13>()
 	mHandlerCalls = 0;
 
 	HttpRequest * req = NULL;
-	HttpOptions * opts = NULL;
+	HttpOptions::ptr_t opts;
 
 	try
 	{
@@ -1350,7 +1345,7 @@ void HttpRequestTestObjectType::test<13>()
 		req = new HttpRequest();
 		ensure("Memory allocated on construction", mMemTotal < GetMemTotal());
 
-		opts = new HttpOptions();
+        opts = HttpOptions::ptr_t(new HttpOptions());
 		opts->setWantHeaders(true);
 		
 		// Issue a GET that succeeds
@@ -1364,13 +1359,12 @@ void HttpRequestTestObjectType::test<13>()
 													 0,	
 												 0,
 													 opts,
-													 NULL,
-													 &handler);
+                                                     HttpHeaders::ptr_t(),
+                                                     &handler);
 		ensure("Valid handle returned for ranged request", handle != LLCORE_HTTP_HANDLE_INVALID);
 
 		// release options
-		opts->release();
-		opts = NULL;
+        opts.reset();
 
 		// Run the notification pump.
 		int count(0);
@@ -1430,11 +1424,7 @@ void HttpRequestTestObjectType::test<13>()
 	catch (...)
 	{
 		stop_thread(req);
-		if (opts)
-		{
-			opts->release();
-			opts = NULL;
-		}
+        opts.reset();
 		delete req;
 		HttpRequest::destroyService();
 		throw;
@@ -1460,7 +1450,7 @@ void HttpRequestTestObjectType::test<14>()
 	mHandlerCalls = 0;
 
 	HttpRequest * req = NULL;
-	HttpOptions * opts = NULL;
+	HttpOptions::ptr_t opts;
 	
 	try
 	{
@@ -1475,7 +1465,7 @@ void HttpRequestTestObjectType::test<14>()
 		req = new HttpRequest();
 		ensure("Memory allocated on construction", mMemTotal < GetMemTotal());
 
-		opts = new HttpOptions();
+        opts = HttpOptions::ptr_t(new HttpOptions);
 		opts->setRetries(0);			// Don't retry
 		opts->setTimeout(2);
 		
@@ -1487,8 +1477,8 @@ void HttpRequestTestObjectType::test<14>()
 													 0,
 													 0,
 													 opts,
-													 NULL,
-													 &handler);
+                                                     HttpHeaders::ptr_t(),
+                                                     &handler);
 		ensure("Valid handle returned for ranged request", handle != LLCORE_HTTP_HANDLE_INVALID);
 
 		// Run the notification pump.
@@ -1528,8 +1518,7 @@ void HttpRequestTestObjectType::test<14>()
 		ensure("Thread actually stopped running", HttpService::isStopped());
 
 		// release options
-		opts->release();
-		opts = NULL;
+        opts.reset();
 		
 		// release the request object
 		delete req;
@@ -1552,11 +1541,7 @@ void HttpRequestTestObjectType::test<14>()
 	catch (...)
 	{
 		stop_thread(req);
-		if (opts)
-		{
-			opts->release();
-			opts = NULL;
-		}
+        opts.reset();
 		delete req;
 		HttpRequest::destroyService();
 		throw;
@@ -1609,9 +1594,9 @@ void HttpRequestTestObjectType::test<15>()
 		HttpHandle handle = req->requestGet(HttpRequest::DEFAULT_POLICY_ID,
 											0U,
 											url_base,
-											NULL,
-											NULL,
-											&handler);
+                                            HttpOptions::ptr_t(),
+                                            HttpHeaders::ptr_t(),
+                                            &handler);
 		ensure("Valid handle returned for ranged request", handle != LLCORE_HTTP_HANDLE_INVALID);
 
 		// Run the notification pump.
@@ -1703,8 +1688,8 @@ void HttpRequestTestObjectType::test<16>()
 	mHandlerCalls = 0;
 
 	HttpRequest * req = NULL;
-	HttpOptions * options = NULL;
-	HttpHeaders * headers = NULL;
+	HttpOptions::ptr_t options;
+	HttpHeaders::ptr_t headers;
 
 	try
 	{
@@ -1719,7 +1704,7 @@ void HttpRequestTestObjectType::test<16>()
 		req = new HttpRequest();
 
 		// options set
-		options = new HttpOptions();
+        options = HttpOptions::ptr_t(new HttpOptions());
 		options->setWantHeaders(true);
 		
 		// Issue a GET that *can* connect
@@ -1776,7 +1761,7 @@ void HttpRequestTestObjectType::test<16>()
 											0U,
 											url_base + "reflect/",
 											options,
-											NULL,
+											HttpHeaders::ptr_t(),
 											&handler);
 		ensure("Valid handle returned for get request", handle != LLCORE_HTTP_HANDLE_INVALID);
 
@@ -1792,7 +1777,7 @@ void HttpRequestTestObjectType::test<16>()
 		ensure("One handler invocation for request", mHandlerCalls == 1);
 
 		// Do a texture-style fetch
-		headers = new HttpHeaders;
+		headers = HttpHeaders::ptr_t(new HttpHeaders);
 		headers->append("Accept", "image/x-j2c");
 		
 		mStatus = HttpStatus(200);
@@ -1897,17 +1882,8 @@ void HttpRequestTestObjectType::test<16>()
 		ensure("Thread actually stopped running", HttpService::isStopped());
 	
 		// release options & headers
-		if (options)
-		{
-			options->release();
-		}
-		options = NULL;
-
-		if (headers)
-		{
-			headers->release();
-		}
-		headers = NULL;
+        options.reset();
+        headers.reset();
 		
 		// release the request object
 		delete req;
@@ -1919,16 +1895,9 @@ void HttpRequestTestObjectType::test<16>()
 	catch (...)
 	{
 		stop_thread(req);
-		if (options)
-		{
-			options->release();
-			options = NULL;
-		}
-		if (headers)
-		{
-			headers->release();
-			headers = NULL;
-		}
+        options.reset();
+        headers.reset();
+
 		delete req;
 		HttpRequest::destroyService();
 		throw;
@@ -1960,8 +1929,8 @@ void HttpRequestTestObjectType::test<17>()
 	mHandlerCalls = 0;
 
 	HttpRequest * req = NULL;
-	HttpOptions * options = NULL;
-	HttpHeaders * headers = NULL;
+	HttpOptions::ptr_t options;
+	HttpHeaders::ptr_t headers;
 	BufferArray * ba = NULL;
 	
 	try
@@ -1977,7 +1946,7 @@ void HttpRequestTestObjectType::test<17>()
 		req = new HttpRequest();
 
 		// options set
-		options = new HttpOptions();
+        options = HttpOptions::ptr_t(new HttpOptions());
 		options->setWantHeaders(true);
 
 		// And a buffer array
@@ -2049,7 +2018,7 @@ void HttpRequestTestObjectType::test<17>()
 											 url_base + "reflect/",
 											 ba,
 											 options,
-											 NULL,
+											 HttpHeaders::ptr_t(),
 											 &handler);
 		ensure("Valid handle returned for get request", handle != LLCORE_HTTP_HANDLE_INVALID);
 		ba->release();
@@ -2095,17 +2064,8 @@ void HttpRequestTestObjectType::test<17>()
 		ensure("Thread actually stopped running", HttpService::isStopped());
 	
 		// release options & headers
-		if (options)
-		{
-			options->release();
-		}
-		options = NULL;
-
-		if (headers)
-		{
-			headers->release();
-		}
-		headers = NULL;
+        options.reset();
+        headers.reset();
 		
 		// release the request object
 		delete req;
@@ -2122,17 +2082,10 @@ void HttpRequestTestObjectType::test<17>()
 			ba->release();
 			ba = NULL;
 		}
-		if (options)
-		{
-			options->release();
-			options = NULL;
-		}
-		if (headers)
-		{
-			headers->release();
-			headers = NULL;
-		}
-		delete req;
+        options.reset();
+        headers.reset();
+
+        delete req;
 		HttpRequest::destroyService();
 		throw;
 	}
@@ -2163,8 +2116,8 @@ void HttpRequestTestObjectType::test<18>()
 	mHandlerCalls = 0;
 
 	HttpRequest * req = NULL;
-	HttpOptions * options = NULL;
-	HttpHeaders * headers = NULL;
+	HttpOptions::ptr_t options;
+	HttpHeaders::ptr_t headers;
 	BufferArray * ba = NULL;
 	
 	try
@@ -2180,7 +2133,7 @@ void HttpRequestTestObjectType::test<18>()
 		req = new HttpRequest();
 
 		// options set
-		options = new HttpOptions();
+		options = HttpOptions::ptr_t(new HttpOptions());
 		options->setWantHeaders(true);
 
 		// And a buffer array
@@ -2253,7 +2206,7 @@ void HttpRequestTestObjectType::test<18>()
 											url_base + "reflect/",
 											ba,
 											options,
-											NULL,
+											HttpHeaders::ptr_t(),
 											&handler);
 		ensure("Valid handle returned for get request", handle != LLCORE_HTTP_HANDLE_INVALID);
 		ba->release();
@@ -2299,17 +2252,8 @@ void HttpRequestTestObjectType::test<18>()
 		ensure("Thread actually stopped running", HttpService::isStopped());
 	
 		// release options & headers
-		if (options)
-		{
-			options->release();
-		}
-		options = NULL;
-
-		if (headers)
-		{
-			headers->release();
-		}
-		headers = NULL;
+        options.reset();
+        headers.reset();
 		
 		// release the request object
 		delete req;
@@ -2326,17 +2270,10 @@ void HttpRequestTestObjectType::test<18>()
 			ba->release();
 			ba = NULL;
 		}
-		if (options)
-		{
-			options->release();
-			options = NULL;
-		}
-		if (headers)
-		{
-			headers->release();
-			headers = NULL;
-		}
-		delete req;
+        options.reset();
+        headers.reset();
+
+        delete req;
 		HttpRequest::destroyService();
 		throw;
 	}
@@ -2367,8 +2304,8 @@ void HttpRequestTestObjectType::test<19>()
 	mHandlerCalls = 0;
 
 	HttpRequest * req = NULL;
-	HttpOptions * options = NULL;
-	HttpHeaders * headers = NULL;
+	HttpOptions::ptr_t options;
+	HttpHeaders::ptr_t headers;
 
 	try
 	{
@@ -2383,11 +2320,11 @@ void HttpRequestTestObjectType::test<19>()
 		req = new HttpRequest();
 
 		// options set
-		options = new HttpOptions();
+        options = HttpOptions::ptr_t(new HttpOptions());
 		options->setWantHeaders(true);
 
 		// headers
-		headers = new HttpHeaders;
+		headers = HttpHeaders::ptr_t(new HttpHeaders);
 		headers->append("Keep-Alive", "120");
 		headers->append("Accept-encoding", "deflate");
 		headers->append("Accept", "text/plain");
@@ -2502,17 +2439,8 @@ void HttpRequestTestObjectType::test<19>()
 		ensure("Thread actually stopped running", HttpService::isStopped());
 	
 		// release options & headers
-		if (options)
-		{
-			options->release();
-		}
-		options = NULL;
-
-		if (headers)
-		{
-			headers->release();
-		}
-		headers = NULL;
+        options.reset();
+        headers.reset();
 		
 		// release the request object
 		delete req;
@@ -2524,16 +2452,9 @@ void HttpRequestTestObjectType::test<19>()
 	catch (...)
 	{
 		stop_thread(req);
-		if (options)
-		{
-			options->release();
-			options = NULL;
-		}
-		if (headers)
-		{
-			headers->release();
-			headers = NULL;
-		}
+        options.reset();
+        headers.reset();
+
 		delete req;
 		HttpRequest::destroyService();
 		throw;
@@ -2565,8 +2486,8 @@ void HttpRequestTestObjectType::test<20>()
 	mHandlerCalls = 0;
 
 	HttpRequest * req = NULL;
-	HttpOptions * options = NULL;
-	HttpHeaders * headers = NULL;
+	HttpOptions::ptr_t options;
+	HttpHeaders::ptr_t headers;
 	BufferArray * ba = NULL;
 	
 	try
@@ -2582,11 +2503,11 @@ void HttpRequestTestObjectType::test<20>()
 		req = new HttpRequest();
 
 		// options set
-		options = new HttpOptions();
+        options = HttpOptions::ptr_t(new HttpOptions());
 		options->setWantHeaders(true);
 
 		// headers
-		headers = new HttpHeaders();
+		headers = HttpHeaders::ptr_t(new HttpHeaders());
 		headers->append("keep-Alive", "120");
 		headers->append("Accept", "text/html");
 		headers->append("content-type", "application/llsd+xml");
@@ -2720,17 +2641,8 @@ void HttpRequestTestObjectType::test<20>()
 		ensure("Thread actually stopped running", HttpService::isStopped());
 	
 		// release options & headers
-		if (options)
-		{
-			options->release();
-		}
-		options = NULL;
-
-		if (headers)
-		{
-			headers->release();
-		}
-		headers = NULL;
+        options.reset();
+        headers.reset();
 		
 		// release the request object
 		delete req;
@@ -2747,16 +2659,8 @@ void HttpRequestTestObjectType::test<20>()
 			ba->release();
 			ba = NULL;
 		}
-		if (options)
-		{
-			options->release();
-			options = NULL;
-		}
-		if (headers)
-		{
-			headers->release();
-			headers = NULL;
-		}
+        options.reset();
+        headers.reset();
 		delete req;
 		HttpRequest::destroyService();
 		throw;
@@ -2788,8 +2692,8 @@ void HttpRequestTestObjectType::test<21>()
 	mHandlerCalls = 0;
 
 	HttpRequest * req = NULL;
-	HttpOptions * options = NULL;
-	HttpHeaders * headers = NULL;
+	HttpOptions::ptr_t options;
+	HttpHeaders::ptr_t headers;
 	BufferArray * ba = NULL;
 	
 	try
@@ -2805,11 +2709,11 @@ void HttpRequestTestObjectType::test<21>()
 		req = new HttpRequest();
 
 		// options set
-		options = new HttpOptions();
+        options = HttpOptions::ptr_t(new HttpOptions());
 		options->setWantHeaders(true);
 
 		// headers
-		headers = new HttpHeaders;
+		headers = HttpHeaders::ptr_t(new HttpHeaders);
 		headers->append("content-type", "text/plain");
 		headers->append("content-type", "text/html");
 		headers->append("content-type", "application/llsd+xml");
@@ -2937,17 +2841,8 @@ void HttpRequestTestObjectType::test<21>()
 		ensure("Thread actually stopped running", HttpService::isStopped());
 	
 		// release options & headers
-		if (options)
-		{
-			options->release();
-		}
-		options = NULL;
-
-		if (headers)
-		{
-			headers->release();
-		}
-		headers = NULL;
+        options.reset();
+        headers.reset();
 		
 		// release the request object
 		delete req;
@@ -2964,16 +2859,8 @@ void HttpRequestTestObjectType::test<21>()
 			ba->release();
 			ba = NULL;
 		}
-		if (options)
-		{
-			options->release();
-			options = NULL;
-		}
-		if (headers)
-		{
-			headers->release();
-			headers = NULL;
-		}
+        options.reset();
+        headers.reset();
 		delete req;
 		HttpRequest::destroyService();
 		throw;
@@ -3000,13 +2887,13 @@ void HttpRequestTestObjectType::test<22>()
 	mMemTotal = GetMemTotal();
 	mHandlerCalls = 0;
 
-	HttpOptions * options = NULL;
+	HttpOptions::ptr_t options;
 	HttpRequest * req = NULL;
 
 	try
 	{
 		// options set
-		options = new HttpOptions();
+        options = HttpOptions::ptr_t(new HttpOptions());
 		options->setRetries(1);			// Partial_File is retryable and can timeout in here
 
 		// Get singletons created
@@ -3035,8 +2922,8 @@ void HttpRequestTestObjectType::test<22>()
 														 0,
 														 25,
 														 options,
-														 NULL,
-														 &handler);
+                                                         HttpHeaders::ptr_t(),
+                                                         &handler);
 			ensure("Valid handle returned for ranged request", handle != LLCORE_HTTP_HANDLE_INVALID);
 		}
 		
@@ -3067,7 +2954,7 @@ void HttpRequestTestObjectType::test<22>()
 														 0,
 														 25,
 														 options,
-														 NULL,
+														 HttpHeaders::ptr_t(),
 														 &handler);
 			ensure("Valid handle returned for ranged request", handle != LLCORE_HTTP_HANDLE_INVALID);
 		}
@@ -3099,8 +2986,8 @@ void HttpRequestTestObjectType::test<22>()
 														 0,
 														 25,
 														 options,
-														 NULL,
-														 &handler);
+                                                         HttpHeaders::ptr_t(),
+                                                         &handler);
 			ensure("Valid handle returned for ranged request", handle != LLCORE_HTTP_HANDLE_INVALID);
 		}
 		
@@ -3144,11 +3031,7 @@ void HttpRequestTestObjectType::test<22>()
 		ensure("Thread actually stopped running", HttpService::isStopped());
 
 		// release options
-		if (options)
-		{
-			options->release();
-			options = NULL;
-		}
+        options.reset();
 		
 		// release the request object
 		delete req;
@@ -3198,7 +3081,7 @@ void HttpRequestTestObjectType::test<23>()
 	mHandlerCalls = 0;
 
 	HttpRequest * req = NULL;
-	HttpOptions * opts = NULL;
+	HttpOptions::ptr_t opts;
 	
 	try
 	{
@@ -3213,7 +3096,7 @@ void HttpRequestTestObjectType::test<23>()
 		req = new HttpRequest();
 		ensure("Memory allocated on construction", mMemTotal < GetMemTotal());
 
-		opts = new HttpOptions();
+        opts = HttpOptions::ptr_t(new HttpOptions());
 		opts->setRetries(1);			// Retry once only
 		opts->setUseRetryAfter(true);	// Try to parse the retry-after header
 		
@@ -3230,8 +3113,8 @@ void HttpRequestTestObjectType::test<23>()
 														 0,
 														 0,
 														 opts,
-														 NULL,
-														 &handler);
+                                                         HttpHeaders::ptr_t(),
+                                                         &handler);
 
 			std::ostringstream testtag;
 			testtag << "Valid handle returned for 503 request #" << i;
@@ -3277,8 +3160,7 @@ void HttpRequestTestObjectType::test<23>()
 		ensure("Thread actually stopped running", HttpService::isStopped());
 
 		// release options
-		opts->release();
-		opts = NULL;
+        opts.reset();
 		
 		// release the request object
 		delete req;
@@ -3299,11 +3181,7 @@ void HttpRequestTestObjectType::test<23>()
 	catch (...)
 	{
 		stop_thread(req);
-		if (opts)
-		{
-			opts->release();
-			opts = NULL;
-		}
+        opts.reset();
 		delete req;
 		HttpRequest::destroyService();
 		throw;
diff --git a/indra/newview/tests/llhttpretrypolicy_test.cpp b/indra/newview/tests/llhttpretrypolicy_test.cpp
index 25e6de46d9..8bd6cc2690 100755
--- a/indra/newview/tests/llhttpretrypolicy_test.cpp
+++ b/indra/newview/tests/llhttpretrypolicy_test.cpp
@@ -285,10 +285,10 @@ void RetryPolicyTestObject::test<7>()
 	ensure_approximately_equals_range("header 2", seconds_to_wait, 7.0F, 2.0F);
 
 	LLCore::HttpResponse *response;
-	LLCore::HttpHeaders *headers;
+	LLCore::HttpHeaders::ptr_t headers;
 
 	response = new LLCore::HttpResponse();
-	headers = new LLCore::HttpHeaders();
+	headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders());
 	response->setStatus(503);
 	response->setHeaders(headers);
 	headers->append(HTTP_IN_HEADER_RETRY_AFTER, std::string("600"));
@@ -299,7 +299,7 @@ void RetryPolicyTestObject::test<7>()
 	response->release();
 
 	response = new LLCore::HttpResponse();
-	headers = new LLCore::HttpHeaders();
+	headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders());
 	response->setStatus(503);
 	response->setHeaders(headers);
 	time(&nowseconds);
-- 
cgit v1.3


From 75b12d79e1aeeef297182e4419df7022ede485f3 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 8 Jul 2015 14:49:08 -0700
Subject: Enforcing constness of refs

---
 indra/llcorehttp/_httpoprequest.cpp | 32 ++++++++++++++++----------------
 indra/llcorehttp/_httpoprequest.h   | 32 ++++++++++++++++----------------
 indra/llcorehttp/httprequest.cpp    | 28 ++++++++++++++--------------
 indra/llcorehttp/httprequest.h      | 28 ++++++++++++++--------------
 indra/llmessage/llcorehttputil.cpp  | 12 ++++++------
 indra/llmessage/llcorehttputil.h    | 34 +++++++++++++++++-----------------
 6 files changed, 83 insertions(+), 83 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/_httpoprequest.cpp b/indra/llcorehttp/_httpoprequest.cpp
index 7baef25aca..e588ed8a9b 100755
--- a/indra/llcorehttp/_httpoprequest.cpp
+++ b/indra/llcorehttp/_httpoprequest.cpp
@@ -281,8 +281,8 @@ HttpStatus HttpOpRequest::cancel()
 HttpStatus HttpOpRequest::setupGet(HttpRequest::policy_t policy_id,
 								   HttpRequest::priority_t priority,
 								   const std::string & url,
-                                   HttpOptions::ptr_t & options,
-								   HttpHeaders::ptr_t & headers)
+                                   const HttpOptions::ptr_t & options,
+								   const HttpHeaders::ptr_t & headers)
 {
 	setupCommon(policy_id, priority, url, NULL, options, headers);
 	mReqMethod = HOR_GET;
@@ -296,8 +296,8 @@ HttpStatus HttpOpRequest::setupGetByteRange(HttpRequest::policy_t policy_id,
 											const std::string & url,
 											size_t offset,
 											size_t len,
-                                            HttpOptions::ptr_t & options,
-                                            HttpHeaders::ptr_t & headers)
+                                            const HttpOptions::ptr_t & options,
+                                            const HttpHeaders::ptr_t & headers)
 {
 	setupCommon(policy_id, priority, url, NULL, options, headers);
 	mReqMethod = HOR_GET;
@@ -316,8 +316,8 @@ HttpStatus HttpOpRequest::setupPost(HttpRequest::policy_t policy_id,
 									HttpRequest::priority_t priority,
 									const std::string & url,
 									BufferArray * body,
-                                    HttpOptions::ptr_t & options,
-                                    HttpHeaders::ptr_t & headers)
+                                    const HttpOptions::ptr_t & options,
+                                    const HttpHeaders::ptr_t & headers)
 {
 	setupCommon(policy_id, priority, url, body, options, headers);
 	mReqMethod = HOR_POST;
@@ -330,8 +330,8 @@ HttpStatus HttpOpRequest::setupPut(HttpRequest::policy_t policy_id,
 								   HttpRequest::priority_t priority,
 								   const std::string & url,
 								   BufferArray * body,
-                                   HttpOptions::ptr_t & options,
-								   HttpHeaders::ptr_t & headers)
+                                   const HttpOptions::ptr_t & options,
+								   const HttpHeaders::ptr_t & headers)
 {
 	setupCommon(policy_id, priority, url, body, options, headers);
 	mReqMethod = HOR_PUT;
@@ -343,8 +343,8 @@ HttpStatus HttpOpRequest::setupPut(HttpRequest::policy_t policy_id,
 HttpStatus HttpOpRequest::setupDelete(HttpRequest::policy_t policy_id,
     HttpRequest::priority_t priority,
     const std::string & url,
-    HttpOptions::ptr_t & options,
-    HttpHeaders::ptr_t & headers)
+    const HttpOptions::ptr_t & options,
+    const HttpHeaders::ptr_t & headers)
 {
     setupCommon(policy_id, priority, url, NULL, options, headers);
     mReqMethod = HOR_DELETE;
@@ -357,8 +357,8 @@ HttpStatus HttpOpRequest::setupPatch(HttpRequest::policy_t policy_id,
     HttpRequest::priority_t priority,
     const std::string & url,
     BufferArray * body,
-    HttpOptions::ptr_t & options,
-    HttpHeaders::ptr_t & headers)
+    const HttpOptions::ptr_t & options,
+    const HttpHeaders::ptr_t & headers)
 {
     setupCommon(policy_id, priority, url, body, options, headers);
     mReqMethod = HOR_PATCH;
@@ -370,8 +370,8 @@ HttpStatus HttpOpRequest::setupPatch(HttpRequest::policy_t policy_id,
 HttpStatus HttpOpRequest::setupCopy(HttpRequest::policy_t policy_id,
     HttpRequest::priority_t priority,
     const std::string & url,
-    HttpOptions::ptr_t & options,
-    HttpHeaders::ptr_t &headers)
+    const HttpOptions::ptr_t & options,
+    const HttpHeaders::ptr_t &headers)
 {
     setupCommon(policy_id, priority, url, NULL, options, headers);
     mReqMethod = HOR_COPY;
@@ -384,8 +384,8 @@ void HttpOpRequest::setupCommon(HttpRequest::policy_t policy_id,
 								HttpRequest::priority_t priority,
 								const std::string & url,
 								BufferArray * body,
-                                HttpOptions::ptr_t & options,
-								HttpHeaders::ptr_t & headers)
+                                const HttpOptions::ptr_t & options,
+								const HttpHeaders::ptr_t & headers)
 {
 	mProcFlags = 0U;
 	mReqPolicy = policy_id;
diff --git a/indra/llcorehttp/_httpoprequest.h b/indra/llcorehttp/_httpoprequest.h
index 42db71e7a0..a9083be02b 100755
--- a/indra/llcorehttp/_httpoprequest.h
+++ b/indra/llcorehttp/_httpoprequest.h
@@ -104,49 +104,49 @@ public:
 	HttpStatus setupGet(HttpRequest::policy_t policy_id,
 						HttpRequest::priority_t priority,
 						const std::string & url,
-						HttpOptions::ptr_t & options,
-						HttpHeaders::ptr_t & headers);
+						const HttpOptions::ptr_t & options,
+						const HttpHeaders::ptr_t & headers);
 	
 	HttpStatus setupGetByteRange(HttpRequest::policy_t policy_id,
 								 HttpRequest::priority_t priority,
 								 const std::string & url,
 								 size_t offset,
 								 size_t len,
-                                 HttpOptions::ptr_t & options,
-								 HttpHeaders::ptr_t & headers);
+                                 const HttpOptions::ptr_t & options,
+								 const HttpHeaders::ptr_t & headers);
 	
 	HttpStatus setupPost(HttpRequest::policy_t policy_id,
 						 HttpRequest::priority_t priority,
 						 const std::string & url,
 						 BufferArray * body,
-                         HttpOptions::ptr_t & options,
-						 HttpHeaders::ptr_t & headers);
+                         const HttpOptions::ptr_t & options,
+						 const HttpHeaders::ptr_t & headers);
 	
 	HttpStatus setupPut(HttpRequest::policy_t policy_id,
 						HttpRequest::priority_t priority,
 						const std::string & url,
 						BufferArray * body,
-                        HttpOptions::ptr_t & options,
-						HttpHeaders::ptr_t & headers);
+                        const HttpOptions::ptr_t & options,
+						const HttpHeaders::ptr_t & headers);
 
     HttpStatus setupDelete(HttpRequest::policy_t policy_id,
                         HttpRequest::priority_t priority,
                         const std::string & url,
-                        HttpOptions::ptr_t & options,
-                        HttpHeaders::ptr_t & headers);
+                        const HttpOptions::ptr_t & options,
+                        const HttpHeaders::ptr_t & headers);
 
     HttpStatus setupPatch(HttpRequest::policy_t policy_id,
                         HttpRequest::priority_t priority,
                         const std::string & url,
                         BufferArray * body,
-                        HttpOptions::ptr_t & options,
-                        HttpHeaders::ptr_t & headers);
+                        const HttpOptions::ptr_t & options,
+                        const HttpHeaders::ptr_t & headers);
 
     HttpStatus setupCopy(HttpRequest::policy_t policy_id,
                         HttpRequest::priority_t priority,
                         const std::string & url,
-                        HttpOptions::ptr_t & options,
-                        HttpHeaders::ptr_t & headers);
+                        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.
@@ -166,8 +166,8 @@ protected:
 					 HttpRequest::priority_t priority,
 					 const std::string & url,
 					 BufferArray * body,
-                     HttpOptions::ptr_t & options,
-					 HttpHeaders::ptr_t & headers);
+                     const HttpOptions::ptr_t & options,
+					 const HttpHeaders::ptr_t & headers);
 
 	// libcurl operational callbacks
 	//
diff --git a/indra/llcorehttp/httprequest.cpp b/indra/llcorehttp/httprequest.cpp
index 4a7352c962..f0dfde6153 100755
--- a/indra/llcorehttp/httprequest.cpp
+++ b/indra/llcorehttp/httprequest.cpp
@@ -197,8 +197,8 @@ HttpStatus HttpRequest::getStatus() const
 HttpHandle HttpRequest::requestGet(policy_t policy_id,
 								   priority_t priority,
 								   const std::string & url,
-                                   HttpOptions::ptr_t & options,
-								   HttpHeaders::ptr_t & headers,
+                                   const HttpOptions::ptr_t & options,
+								   const HttpHeaders::ptr_t & headers,
 								   HttpHandler * user_handler)
 {
 	HttpStatus status;
@@ -231,8 +231,8 @@ HttpHandle HttpRequest::requestGetByteRange(policy_t policy_id,
 											const std::string & url,
 											size_t offset,
 											size_t len,
-                                            HttpOptions::ptr_t & options,
-											HttpHeaders::ptr_t & headers,
+                                            const HttpOptions::ptr_t & options,
+											const HttpHeaders::ptr_t & headers,
 											HttpHandler * user_handler)
 {
 	HttpStatus status;
@@ -264,8 +264,8 @@ HttpHandle HttpRequest::requestPost(policy_t policy_id,
 									priority_t priority,
 									const std::string & url,
 									BufferArray * body,
-                                    HttpOptions::ptr_t & options,
-									HttpHeaders::ptr_t & headers,
+                                    const HttpOptions::ptr_t & options,
+									const HttpHeaders::ptr_t & headers,
 									HttpHandler * user_handler)
 {
 	HttpStatus status;
@@ -297,8 +297,8 @@ HttpHandle HttpRequest::requestPut(policy_t policy_id,
 								   priority_t priority,
 								   const std::string & url,
 								   BufferArray * body,
-                                   HttpOptions::ptr_t & options,
-								   HttpHeaders::ptr_t & headers,
+                                   const HttpOptions::ptr_t & options,
+								   const HttpHeaders::ptr_t & headers,
 								   HttpHandler * user_handler)
 {
 	HttpStatus status;
@@ -328,8 +328,8 @@ HttpHandle HttpRequest::requestPut(policy_t policy_id,
 HttpHandle HttpRequest::requestDelete(policy_t policy_id,
     priority_t priority,
     const std::string & url,
-    HttpOptions::ptr_t & options,
-    HttpHeaders::ptr_t & headers,
+    const HttpOptions::ptr_t & options,
+    const HttpHeaders::ptr_t & headers,
     HttpHandler * user_handler)
 {
     HttpStatus status;
@@ -360,8 +360,8 @@ HttpHandle HttpRequest::requestPatch(policy_t policy_id,
     priority_t priority,
     const std::string & url,
     BufferArray * body,
-    HttpOptions::ptr_t & options,
-    HttpHeaders::ptr_t & headers,
+    const HttpOptions::ptr_t & options,
+    const HttpHeaders::ptr_t & headers,
     HttpHandler * user_handler)
 {
     HttpStatus status;
@@ -391,8 +391,8 @@ HttpHandle HttpRequest::requestPatch(policy_t policy_id,
 HttpHandle HttpRequest::requestCopy(policy_t policy_id,
     priority_t priority,
     const std::string & url,
-    HttpOptions::ptr_t & options,
-    HttpHeaders::ptr_t & headers,
+    const HttpOptions::ptr_t & options,
+    const HttpHeaders::ptr_t & headers,
     HttpHandler * user_handler)
 {
     HttpStatus status;
diff --git a/indra/llcorehttp/httprequest.h b/indra/llcorehttp/httprequest.h
index 58aea1444c..20a223c482 100755
--- a/indra/llcorehttp/httprequest.h
+++ b/indra/llcorehttp/httprequest.h
@@ -348,8 +348,8 @@ public:
 	HttpHandle requestGet(policy_t policy_id,
 						  priority_t priority,
 						  const std::string & url,
-                          HttpOptions::ptr_t & options,
-						  HttpHeaders::ptr_t & headers,
+                          const HttpOptions::ptr_t & options,
+						  const HttpHeaders::ptr_t & headers,
 						  HttpHandler * handler);
 
 
@@ -391,8 +391,8 @@ public:
 								   const std::string & url,
 								   size_t offset,
 								   size_t len,
-                                   HttpOptions::ptr_t & options,
-								   HttpHeaders::ptr_t & headers,
+                                   const HttpOptions::ptr_t & options,
+								   const HttpHeaders::ptr_t & headers,
 								   HttpHandler * handler);
 
 
@@ -432,8 +432,8 @@ public:
 						   priority_t priority,
 						   const std::string & url,
 						   BufferArray * body,
-                           HttpOptions::ptr_t & options,
-						   HttpHeaders::ptr_t & headers,
+                           const HttpOptions::ptr_t & options,
+						   const HttpHeaders::ptr_t & headers,
 						   HttpHandler * handler);
 
 
@@ -473,8 +473,8 @@ public:
 						  priority_t priority,
 						  const std::string & url,
 						  BufferArray * body,
-                          HttpOptions::ptr_t & options,
-						  HttpHeaders::ptr_t & headers,
+                          const HttpOptions::ptr_t & options,
+						  const HttpHeaders::ptr_t & headers,
 						  HttpHandler * handler);
 
 
@@ -493,8 +493,8 @@ public:
     HttpHandle requestDelete(policy_t policy_id,
             priority_t priority,
             const std::string & url,
-            HttpOptions::ptr_t & options,
-            HttpHeaders::ptr_t & headers,
+            const HttpOptions::ptr_t & options,
+            const HttpHeaders::ptr_t & headers,
             HttpHandler * user_handler);
 
     /// Queue a full HTTP PUT.  Query arguments and body may
@@ -516,8 +516,8 @@ public:
             priority_t priority,
             const std::string & url,
             BufferArray * body,
-            HttpOptions::ptr_t & options,
-            HttpHeaders::ptr_t & headers,
+            const HttpOptions::ptr_t & options,
+            const HttpHeaders::ptr_t & headers,
             HttpHandler * user_handler);
 
     /// Queue a full HTTP PUT.  Query arguments and body may
@@ -535,8 +535,8 @@ public:
     HttpHandle requestCopy(policy_t policy_id,
             priority_t priority,
             const std::string & url,
-            HttpOptions::ptr_t & options,
-            HttpHeaders::ptr_t & headers,
+            const HttpOptions::ptr_t & options,
+            const HttpHeaders::ptr_t & headers,
             HttpHandler * user_handler);
        
     /// Queue a NoOp request.
diff --git a/indra/llmessage/llcorehttputil.cpp b/indra/llmessage/llcorehttputil.cpp
index 5b5929383a..a2004db30a 100644
--- a/indra/llmessage/llcorehttputil.cpp
+++ b/indra/llmessage/llcorehttputil.cpp
@@ -102,8 +102,8 @@ HttpHandle requestPostWithLLSD(HttpRequest * request,
     HttpRequest::priority_t priority,
     const std::string & url,
     const LLSD & body,
-    HttpOptions::ptr_t options,
-    HttpHeaders::ptr_t headers,
+    const HttpOptions::ptr_t &options,
+    const HttpHeaders::ptr_t &headers,
     HttpHandler * handler)
 {
     HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
@@ -129,8 +129,8 @@ HttpHandle requestPutWithLLSD(HttpRequest * request,
     HttpRequest::priority_t priority,
     const std::string & url,
     const LLSD & body,
-    HttpOptions::ptr_t options,
-    HttpHeaders::ptr_t headers,
+    const HttpOptions::ptr_t &options,
+    const HttpHeaders::ptr_t &headers,
     HttpHandler * handler)
 {
     HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
@@ -155,8 +155,8 @@ HttpHandle requestPatchWithLLSD(HttpRequest * request,
     HttpRequest::priority_t priority,
     const std::string & url,
     const LLSD & body,
-    HttpOptions::ptr_t options,
-    HttpHeaders::ptr_t headers,
+    const HttpOptions::ptr_t &options,
+    const HttpHeaders::ptr_t &headers,
     HttpHandler * handler)
 {
     HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 3dd13d0a0c..6d8f333c72 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -107,21 +107,21 @@ std::string responseToString(LLCore::HttpResponse * response);
 ///						a now-useless HttpHandler object.
 ///
 LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest * request,
-									   LLCore::HttpRequest::policy_t policy_id,
-									   LLCore::HttpRequest::priority_t priority,
-									   const std::string & url,
-									   const LLSD & body,
-                                       LLCore::HttpOptions::ptr_t options,
-									   LLCore::HttpHeaders::ptr_t headers,
-									   LLCore::HttpHandler * handler);
+    LLCore::HttpRequest::policy_t policy_id,
+    LLCore::HttpRequest::priority_t priority,
+    const std::string & url,
+    const LLSD & body,
+    const LLCore::HttpOptions::ptr_t &options,
+    const LLCore::HttpHeaders::ptr_t &headers,
+    LLCore::HttpHandler * handler);
 
 inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & request,
 	LLCore::HttpRequest::policy_t policy_id,
 	LLCore::HttpRequest::priority_t priority,
 	const std::string & url,
 	const LLSD & body,
-	LLCore::HttpOptions::ptr_t & options,
-	LLCore::HttpHeaders::ptr_t & headers,
+	const LLCore::HttpOptions::ptr_t & options,
+	const LLCore::HttpHeaders::ptr_t & headers,
 	LLCore::HttpHandler * handler)
 {
     return requestPostWithLLSD(request.get(), policy_id, priority,
@@ -164,8 +164,8 @@ LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest * request,
 	LLCore::HttpRequest::priority_t priority,
 	const std::string & url,
 	const LLSD & body,
-	LLCore::HttpOptions::ptr_t options,
-	LLCore::HttpHeaders::ptr_t headers,
+	const LLCore::HttpOptions::ptr_t &options,
+	const LLCore::HttpHeaders::ptr_t &headers,
 	LLCore::HttpHandler * handler);
 
 inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -173,8 +173,8 @@ inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & reques
 	LLCore::HttpRequest::priority_t priority,
 	const std::string & url,
 	const LLSD & body,
-	LLCore::HttpOptions::ptr_t & options,
-	LLCore::HttpHeaders::ptr_t & headers,
+	const LLCore::HttpOptions::ptr_t & options,
+	const LLCore::HttpHeaders::ptr_t & headers,
 	LLCore::HttpHandler * handler)
 {
     return requestPutWithLLSD(request.get(), policy_id, priority,
@@ -216,8 +216,8 @@ LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest * request,
     LLCore::HttpRequest::priority_t priority,
     const std::string & url,
     const LLSD & body,
-    LLCore::HttpOptions::ptr_t options,
-    LLCore::HttpHeaders::ptr_t headers,
+    const LLCore::HttpOptions::ptr_t &options,
+    const LLCore::HttpHeaders::ptr_t &headers,
     LLCore::HttpHandler * handler);
 
 inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -225,8 +225,8 @@ inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & requ
     LLCore::HttpRequest::priority_t priority,
     const std::string & url,
     const LLSD & body,
-    LLCore::HttpOptions::ptr_t & options,
-    LLCore::HttpHeaders::ptr_t & headers,
+    const LLCore::HttpOptions::ptr_t & options,
+    const LLCore::HttpHeaders::ptr_t & headers,
     LLCore::HttpHandler * handler)
 {
     return requestPatchWithLLSD(request.get(), policy_id, priority,
-- 
cgit v1.3


From 675b6a807435a2c36297285dc307014141dd7960 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 8 Jul 2015 15:16:54 -0700
Subject: Fix the sample.

---
 indra/llcorehttp/examples/http_texture_load.cpp | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/examples/http_texture_load.cpp b/indra/llcorehttp/examples/http_texture_load.cpp
index 13c9f90b2e..737282c7df 100755
--- a/indra/llcorehttp/examples/http_texture_load.cpp
+++ b/indra/llcorehttp/examples/http_texture_load.cpp
@@ -121,7 +121,7 @@ public:
 	int							mRetriesHttp503;
 	int							mSuccesses;
 	long						mByteCount;
-	LLCore::HttpHeaders *		mHeaders;
+	LLCore::HttpHeaders::ptr_t	mHeaders;
 };
 
 
@@ -363,8 +363,7 @@ int main(int argc, char** argv)
 	// Clean up
 	hr->requestStopThread(NULL);
 	ms_sleep(1000);
-	opt->release();
-	opt = NULL;
+    opt.reset();
 	delete hr;
 	LLCore::HttpRequest::destroyService();
 	term_curl();
@@ -427,18 +426,13 @@ WorkingSet::WorkingSet()
 {
 	mAssets.reserve(30000);
 
-	mHeaders = new LLCore::HttpHeaders;
+	mHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders);
 	mHeaders->append("Accept", "image/x-j2c");
 }
 
 
 WorkingSet::~WorkingSet()
 {
-	if (mHeaders)
-	{
-		mHeaders->release();
-		mHeaders = NULL;
-	}
 }
 
 
-- 
cgit v1.3


From 657944cda7228ba824239d94b270160ac0460934 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 9 Jul 2015 21:42:34 -0400
Subject: Suppress http_proxy env var for llcorehttp integration test.
 Sometimes it can be useful to have http_proxy set in the environment, but if
 we leave it set while INTEGRATION_TEST_llcorehttp is running, the test hangs.
 Suppress that variable for that integration test.

---
 indra/llcorehttp/CMakeLists.txt | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/CMakeLists.txt b/indra/llcorehttp/CMakeLists.txt
index a0b1ea13b1..9631e960c5 100755
--- a/indra/llcorehttp/CMakeLists.txt
+++ b/indra/llcorehttp/CMakeLists.txt
@@ -134,9 +134,13 @@ if (LL_TESTS)
       ${BOOST_THREAD_LIBRARY}
       )
 
+  # If http_proxy is in the current environment (e.g. to fetch s3-proxy
+  # autobuild packages), suppress it for this integration test: it screws up
+  # the tests.
   LL_ADD_INTEGRATION_TEST(llcorehttp
                           "${llcorehttp_TEST_SOURCE_FILES}"
                           "${test_libs}"
+                          "-Dhttp_proxy"
                           ${PYTHON_EXECUTABLE}
                           "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_llcorehttp_peer.py"
                           )
-- 
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/llcorehttp')

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 6a6e914286b17d022850e0dadd2f77f73663bb94 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Tue, 18 Aug 2015 16:35:03 -0700
Subject: MAINT-5506: Establish circular dependency between LLMessage &
 LLCoreHttp

---
 indra/llcorehttp/CMakeLists.txt | 1 +
 indra/llmessage/CMakeLists.txt  | 1 +
 2 files changed, 2 insertions(+)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/CMakeLists.txt b/indra/llcorehttp/CMakeLists.txt
index 9631e960c5..4b00593dd0 100755
--- a/indra/llcorehttp/CMakeLists.txt
+++ b/indra/llcorehttp/CMakeLists.txt
@@ -93,6 +93,7 @@ target_link_libraries(
   ${OPENSSL_LIBRARIES}
   ${CRYPTO_LIBRARIES}
   ${BOOST_THREAD_LIBRARY}
+  ${LLMESSAGE_LIBRARIES}
   )
 
 # tests
diff --git a/indra/llmessage/CMakeLists.txt b/indra/llmessage/CMakeLists.txt
index e08127eebf..9739f7c607 100755
--- a/indra/llmessage/CMakeLists.txt
+++ b/indra/llmessage/CMakeLists.txt
@@ -231,6 +231,7 @@ target_link_libraries(
   ${OPENSSL_LIBRARIES}
   ${CRYPTO_LIBRARIES}
   ${XMLRPCEPI_LIBRARIES}
+  ${LLCOREHTTP_LIBRARIES}
   ${BOOST_COROUTINE_LIBRARY}
   ${BOOST_CONTEXT_LIBRARY}
   ${BOOST_SYSTEM_LIBRARY}
-- 
cgit v1.3


From 921478803c7be857b9131f2882cbc92d3fc1caa7 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 19 Aug 2015 09:07:50 -0700
Subject: Break circular dep.  Things get cranky.

---
 indra/llcorehttp/CMakeLists.txt | 1 -
 1 file changed, 1 deletion(-)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/CMakeLists.txt b/indra/llcorehttp/CMakeLists.txt
index 4b00593dd0..9631e960c5 100755
--- a/indra/llcorehttp/CMakeLists.txt
+++ b/indra/llcorehttp/CMakeLists.txt
@@ -93,7 +93,6 @@ target_link_libraries(
   ${OPENSSL_LIBRARIES}
   ${CRYPTO_LIBRARIES}
   ${BOOST_THREAD_LIBRARY}
-  ${LLMESSAGE_LIBRARIES}
   )
 
 # tests
-- 
cgit v1.3


From 907efc9cc9bcf4a935ed0e1bd17b19da2bb99dce Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Tue, 15 Sep 2015 17:01:26 -0700
Subject: MAINT-5507: Remove llcurl, move constant values and untilities to
 llcorehttp lib

---
 indra/llcorehttp/CMakeLists.txt                    |   2 +
 indra/llcorehttp/httpcommon.cpp                    | 162 +++++++++-
 indra/llcorehttp/httpcommon.h                      |  14 +
 indra/llcorehttp/llhttpconstants.cpp               | 135 ++++++++
 indra/llcorehttp/llhttpconstants.h                 | 219 +++++++++++++
 indra/llcrashlogger/llcrashlogger.cpp              |  11 +-
 indra/llmessage/CMakeLists.txt                     |   4 -
 indra/llmessage/llcurl.cpp                         | 360 ---------------------
 indra/llmessage/llcurl.h                           | 142 --------
 indra/llmessage/llhttpconstants.cpp                | 226 -------------
 indra/llmessage/llhttpconstants.h                  | 226 -------------
 indra/llmessage/llproxy.cpp                        |  13 +-
 indra/llmessage/llproxy.h                          |   2 +-
 indra/llmessage/lltrustedmessageservice.cpp        |   1 +
 indra/llmessage/message.h                          |   1 -
 indra/newview/llaisapi.h                           |   1 -
 indra/newview/llappcorehttp.cpp                    |   3 +
 indra/newview/llappviewer.cpp                      |  13 +-
 indra/newview/llfloaterabout.cpp                   |   1 -
 indra/newview/llhttpretrypolicy.cpp                |  47 ++-
 indra/newview/llhttpretrypolicy.h                  |   2 +
 indra/newview/llinventorymodel.h                   |   1 -
 indra/newview/llmediadataclient.cpp                |  10 +-
 indra/newview/llmeshrepository.cpp                 |   1 -
 indra/newview/llpanellogin.cpp                     |   1 -
 indra/newview/lltexturefetch.h                     |   1 -
 indra/newview/llxmlrpctransaction.cpp              |   2 +-
 indra/newview/pipeline.cpp                         |   1 -
 indra/newview/tests/llhttpretrypolicy_test.cpp     |   6 +-
 indra/test/message_tut.cpp                         |   2 +-
 .../updater/llupdatedownloader.cpp                 |  54 ++--
 31 files changed, 631 insertions(+), 1033 deletions(-)
 create mode 100755 indra/llcorehttp/llhttpconstants.cpp
 create mode 100755 indra/llcorehttp/llhttpconstants.h
 delete mode 100755 indra/llmessage/llcurl.cpp
 delete mode 100755 indra/llmessage/llcurl.h
 delete mode 100755 indra/llmessage/llhttpconstants.cpp
 delete mode 100755 indra/llmessage/llhttpconstants.h

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/CMakeLists.txt b/indra/llcorehttp/CMakeLists.txt
index 9631e960c5..161823079b 100755
--- a/indra/llcorehttp/CMakeLists.txt
+++ b/indra/llcorehttp/CMakeLists.txt
@@ -26,6 +26,7 @@ set(llcorehttp_SOURCE_FILES
     bufferarray.cpp
     bufferstream.cpp
     httpcommon.cpp
+    llhttpconstants.cpp
     httpheaders.cpp
     httpoptions.cpp
     httprequest.cpp
@@ -51,6 +52,7 @@ set(llcorehttp_HEADER_FILES
     bufferarray.h
     bufferstream.h
     httpcommon.h
+    llhttpconstants.h
     httphandler.h
     httpheaders.h
     httpoptions.h
diff --git a/indra/llcorehttp/httpcommon.cpp b/indra/llcorehttp/httpcommon.cpp
index 99238ea920..c606f2b754 100755
--- a/indra/llcorehttp/httpcommon.cpp
+++ b/indra/llcorehttp/httpcommon.cpp
@@ -23,12 +23,24 @@
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
+#if LL_WINDOWS
+#define SAFE_SSL 1
+#elif LL_DARWIN
+#define SAFE_SSL 1
+#else
+#define SAFE_SSL 1
+#endif
 
+#include "linden_common.h"		// Modifies curl/curl.h interfaces
 #include "httpcommon.h"
-
+#include "llmutex.h"
+#include "llthread.h"
 #include <curl/curl.h>
 #include <string>
 #include <sstream>
+#if SAFE_SSL
+#include <openssl/crypto.h>
+#endif
 
 
 namespace LLCore
@@ -263,5 +275,151 @@ bool HttpStatus::isRetryable() const
 			*this == inv_cont_range);	// Short data read disagrees with content-range
 }
 
-} // end namespace LLCore
+namespace LLHttp
+{
+namespace
+{
+typedef boost::shared_ptr<LLMutex> LLMutex_ptr;
+std::vector<LLMutex_ptr> sSSLMutex;
+
+CURL *getCurlTemplateHandle()
+{
+    static CURL *curlpTemplateHandle = NULL;
+
+    if (curlpTemplateHandle == NULL)
+    {	// Late creation of the template curl handle
+        curlpTemplateHandle = curl_easy_init();
+        if (curlpTemplateHandle == NULL)
+        {
+            LL_WARNS() << "curl error calling curl_easy_init()" << LL_ENDL;
+        }
+        else
+        {
+            CURLcode result = curl_easy_setopt(curlpTemplateHandle, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
+            check_curl_code(result, CURLOPT_IPRESOLVE);
+            result = curl_easy_setopt(curlpTemplateHandle, CURLOPT_NOSIGNAL, 1);
+            check_curl_code(result, CURLOPT_NOSIGNAL);
+            result = curl_easy_setopt(curlpTemplateHandle, CURLOPT_NOPROGRESS, 1);
+            check_curl_code(result, CURLOPT_NOPROGRESS);
+            result = curl_easy_setopt(curlpTemplateHandle, CURLOPT_ENCODING, "");
+            check_curl_code(result, CURLOPT_ENCODING);
+            result = curl_easy_setopt(curlpTemplateHandle, CURLOPT_AUTOREFERER, 1);
+            check_curl_code(result, CURLOPT_AUTOREFERER);
+            result = curl_easy_setopt(curlpTemplateHandle, CURLOPT_FOLLOWLOCATION, 1);
+            check_curl_code(result, CURLOPT_FOLLOWLOCATION);
+            result = curl_easy_setopt(curlpTemplateHandle, CURLOPT_SSL_VERIFYPEER, 1);
+            check_curl_code(result, CURLOPT_SSL_VERIFYPEER);
+            result = curl_easy_setopt(curlpTemplateHandle, CURLOPT_SSL_VERIFYHOST, 0);
+            check_curl_code(result, CURLOPT_SSL_VERIFYHOST);
+
+            // The Linksys WRT54G V5 router has an issue with frequent
+            // DNS lookups from LAN machines.  If they happen too often,
+            // like for every HTTP request, the router gets annoyed after
+            // about 700 or so requests and starts issuing TCP RSTs to
+            // new connections.  Reuse the DNS lookups for even a few
+            // seconds and no RSTs.
+            result = curl_easy_setopt(curlpTemplateHandle, CURLOPT_DNS_CACHE_TIMEOUT, 15);
+            check_curl_code(result, CURLOPT_DNS_CACHE_TIMEOUT);
+        }
+    }
+
+    return curlpTemplateHandle;
+}
+    
+LLMutex *getCurlMutex()
+{
+    static LLMutex* sHandleMutexp = NULL;
+
+    if (!sHandleMutexp)
+    {
+        sHandleMutexp = new LLMutex(NULL);
+    }
+
+    return sHandleMutexp;
+}
+
+void deallocateEasyCurl(CURL *curlp)
+{
+    LLMutexLock lock(getCurlMutex());
+
+    curl_easy_cleanup(curlp);
+}
+
+
+#if SAFE_SSL
+//static
+void ssl_locking_callback(int mode, int type, const char *file, int line)
+{
+    if (mode & CRYPTO_LOCK)
+    {
+        sSSLMutex[type]->lock();
+    }
+    else
+    {
+        sSSLMutex[type]->unlock();
+    }
+}
+
+//static
+unsigned long ssl_thread_id(void)
+{
+    return LLThread::currentID();
+}
+#endif
 
+
+}
+
+void initialize()
+{
+    // Do not change this "unless you are familiar with and mean to control 
+    // internal operations of libcurl"
+    // - http://curl.haxx.se/libcurl/c/curl_global_init.html
+    CURLcode code = curl_global_init(CURL_GLOBAL_ALL);
+
+    check_curl_code(code, CURL_GLOBAL_ALL);
+
+#if SAFE_SSL
+    S32 mutex_count = CRYPTO_num_locks();
+    for (S32 i = 0; i < mutex_count; i++)
+    {
+        sSSLMutex.push_back(LLMutex_ptr(new LLMutex(NULL)));
+    }
+    CRYPTO_set_id_callback(&ssl_thread_id);
+    CRYPTO_set_locking_callback(&ssl_locking_callback);
+#endif
+
+}
+
+
+CURL_ptr createEasyHandle()
+{
+    LLMutexLock lock(getCurlMutex());
+
+    CURL* handle = curl_easy_duphandle(getCurlTemplateHandle());
+
+    return CURL_ptr(handle, &deallocateEasyCurl);
+}
+
+std::string getCURLVersion()
+{
+    return std::string(curl_version());
+}
+
+void check_curl_code(CURLcode code, int curl_setopt_option)
+{
+    if (CURLE_OK != code)
+    {
+        // Comment from old llcurl code which may no longer apply:
+        //
+        // linux appears to throw a curl error once per session for a bad initialization
+        // at a pretty random time (when enabling cookies).
+        LL_WARNS() << "libcurl error detected:  " << curl_easy_strerror(code)
+            << ", curl_easy_setopt option:  " << curl_setopt_option
+            << LL_ENDL;
+    }
+
+}
+
+}
+} // end namespace LLCore
diff --git a/indra/llcorehttp/httpcommon.h b/indra/llcorehttp/httpcommon.h
index 898d3d47fa..3e98600a92 100755
--- a/indra/llcorehttp/httpcommon.h
+++ b/indra/llcorehttp/httpcommon.h
@@ -193,6 +193,7 @@
 #include "boost/weak_ptr.hpp"
 #include "boost/function.hpp"
 #include <string>
+#include <curl/curl.h>
 
 namespace LLCore
 {
@@ -490,6 +491,19 @@ private:
 
 }; // end struct HttpStatus
 
+///  A namespace for several free methods and low level utilities. 
+namespace LLHttp
+{
+    typedef boost::shared_ptr<CURL> CURL_ptr;
+
+    void initialize();
+
+    CURL_ptr createEasyHandle();
+    std::string getCURLVersion();
+
+    void check_curl_code(CURLcode code, int curl_setopt_option);
+}
+
 }  // end namespace LLCore
 
 #endif	// _LLCORE_HTTP_COMMON_H_
diff --git a/indra/llcorehttp/llhttpconstants.cpp b/indra/llcorehttp/llhttpconstants.cpp
new file mode 100755
index 0000000000..71d4f19408
--- /dev/null
+++ b/indra/llcorehttp/llhttpconstants.cpp
@@ -0,0 +1,135 @@
+/** 
+ * @file llhttpconstants.cpp
+ * @brief Implementation of the HTTP request / response constant lookups
+ *
+ * $LicenseInfo:firstyear=2013&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2013-2014, 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 "llhttpconstants.h"
+#include "lltimer.h"
+
+// for curl_getdate() (apparently parsing RFC 1123 dates is hard)
+#include <curl/curl.h>
+
+// Outgoing headers. Do *not* use these to check incoming headers.
+// For incoming headers, use the lower-case headers, below.
+const std::string HTTP_OUT_HEADER_ACCEPT("Accept");
+const std::string HTTP_OUT_HEADER_ACCEPT_CHARSET("Accept-Charset");
+const std::string HTTP_OUT_HEADER_ACCEPT_ENCODING("Accept-Encoding");
+const std::string HTTP_OUT_HEADER_ACCEPT_LANGUAGE("Accept-Language");
+const std::string HTTP_OUT_HEADER_ACCEPT_RANGES("Accept-Ranges");
+const std::string HTTP_OUT_HEADER_AGE("Age");
+const std::string HTTP_OUT_HEADER_ALLOW("Allow");
+const std::string HTTP_OUT_HEADER_AUTHORIZATION("Authorization");
+const std::string HTTP_OUT_HEADER_CACHE_CONTROL("Cache-Control");
+const std::string HTTP_OUT_HEADER_CONNECTION("Connection");
+const std::string HTTP_OUT_HEADER_CONTENT_DESCRIPTION("Content-Description");
+const std::string HTTP_OUT_HEADER_CONTENT_ENCODING("Content-Encoding");
+const std::string HTTP_OUT_HEADER_CONTENT_ID("Content-ID");
+const std::string HTTP_OUT_HEADER_CONTENT_LANGUAGE("Content-Language");
+const std::string HTTP_OUT_HEADER_CONTENT_LENGTH("Content-Length");
+const std::string HTTP_OUT_HEADER_CONTENT_LOCATION("Content-Location");
+const std::string HTTP_OUT_HEADER_CONTENT_MD5("Content-MD5");
+const std::string HTTP_OUT_HEADER_CONTENT_RANGE("Content-Range");
+const std::string HTTP_OUT_HEADER_CONTENT_TRANSFER_ENCODING("Content-Transfer-Encoding");
+const std::string HTTP_OUT_HEADER_CONTENT_TYPE("Content-Type");
+const std::string HTTP_OUT_HEADER_COOKIE("Cookie");
+const std::string HTTP_OUT_HEADER_DATE("Date");
+const std::string HTTP_OUT_HEADER_DESTINATION("Destination");
+const std::string HTTP_OUT_HEADER_ETAG("ETag");
+const std::string HTTP_OUT_HEADER_EXPECT("Expect");
+const std::string HTTP_OUT_HEADER_EXPIRES("Expires");
+const std::string HTTP_OUT_HEADER_FROM("From");
+const std::string HTTP_OUT_HEADER_HOST("Host");
+const std::string HTTP_OUT_HEADER_IF_MATCH("If-Match");
+const std::string HTTP_OUT_HEADER_IF_MODIFIED_SINCE("If-Modified-Since");
+const std::string HTTP_OUT_HEADER_IF_NONE_MATCH("If-None-Match");
+const std::string HTTP_OUT_HEADER_IF_RANGE("If-Range");
+const std::string HTTP_OUT_HEADER_IF_UNMODIFIED_SINCE("If-Unmodified-Since");
+const std::string HTTP_OUT_HEADER_KEEP_ALIVE("Keep-Alive");
+const std::string HTTP_OUT_HEADER_LAST_MODIFIED("Last-Modified");
+const std::string HTTP_OUT_HEADER_LOCATION("Location");
+const std::string HTTP_OUT_HEADER_MAX_FORWARDS("Max-Forwards");
+const std::string HTTP_OUT_HEADER_MIME_VERSION("MIME-Version");
+const std::string HTTP_OUT_HEADER_PRAGMA("Pragma");
+const std::string HTTP_OUT_HEADER_PROXY_AUTHENTICATE("Proxy-Authenticate");
+const std::string HTTP_OUT_HEADER_PROXY_AUTHORIZATION("Proxy-Authorization");
+const std::string HTTP_OUT_HEADER_RANGE("Range");
+const std::string HTTP_OUT_HEADER_REFERER("Referer");
+const std::string HTTP_OUT_HEADER_RETRY_AFTER("Retry-After");
+const std::string HTTP_OUT_HEADER_SERVER("Server");
+const std::string HTTP_OUT_HEADER_SET_COOKIE("Set-Cookie");
+const std::string HTTP_OUT_HEADER_TE("TE");
+const std::string HTTP_OUT_HEADER_TRAILER("Trailer");
+const std::string HTTP_OUT_HEADER_TRANSFER_ENCODING("Transfer-Encoding");
+const std::string HTTP_OUT_HEADER_UPGRADE("Upgrade");
+const std::string HTTP_OUT_HEADER_USER_AGENT("User-Agent");
+const std::string HTTP_OUT_HEADER_VARY("Vary");
+const std::string HTTP_OUT_HEADER_VIA("Via");
+const std::string HTTP_OUT_HEADER_WARNING("Warning");
+const std::string HTTP_OUT_HEADER_WWW_AUTHENTICATE("WWW-Authenticate");
+
+// Incoming headers are normalized to lower-case.
+const std::string HTTP_IN_HEADER_ACCEPT_LANGUAGE("accept-language");
+const std::string HTTP_IN_HEADER_CACHE_CONTROL("cache-control");
+const std::string HTTP_IN_HEADER_CONTENT_LENGTH("content-length");
+const std::string HTTP_IN_HEADER_CONTENT_LOCATION("content-location");
+const std::string HTTP_IN_HEADER_CONTENT_TYPE("content-type");
+const std::string HTTP_IN_HEADER_HOST("host");
+const std::string HTTP_IN_HEADER_LOCATION("location");
+const std::string HTTP_IN_HEADER_RETRY_AFTER("retry-after");
+const std::string HTTP_IN_HEADER_SET_COOKIE("set-cookie");
+const std::string HTTP_IN_HEADER_USER_AGENT("user-agent");
+const std::string HTTP_IN_HEADER_X_FORWARDED_FOR("x-forwarded-for");
+
+const std::string HTTP_CONTENT_LLSD_XML("application/llsd+xml");
+const std::string HTTP_CONTENT_OCTET_STREAM("application/octet-stream");
+const std::string HTTP_CONTENT_VND_LL_MESH("application/vnd.ll.mesh");
+const std::string HTTP_CONTENT_XML("application/xml");
+const std::string HTTP_CONTENT_JSON("application/json");
+const std::string HTTP_CONTENT_TEXT_HTML("text/html");
+const std::string HTTP_CONTENT_TEXT_HTML_UTF8("text/html; charset=utf-8");
+const std::string HTTP_CONTENT_TEXT_PLAIN_UTF8("text/plain; charset=utf-8");
+const std::string HTTP_CONTENT_TEXT_LLSD("text/llsd");
+const std::string HTTP_CONTENT_TEXT_XML("text/xml");
+const std::string HTTP_CONTENT_TEXT_LSL("text/lsl");
+const std::string HTTP_CONTENT_TEXT_PLAIN("text/plain");
+const std::string HTTP_CONTENT_IMAGE_X_J2C("image/x-j2c");
+const std::string HTTP_CONTENT_IMAGE_J2C("image/j2c");
+const std::string HTTP_CONTENT_IMAGE_JPEG("image/jpeg");
+const std::string HTTP_CONTENT_IMAGE_PNG("image/png");
+const std::string HTTP_CONTENT_IMAGE_BMP("image/bmp");
+
+const std::string HTTP_NO_CACHE("no-cache");
+const std::string HTTP_NO_CACHE_CONTROL("no-cache, max-age=0");
+
+const std::string HTTP_VERB_INVALID("(invalid)");
+const std::string HTTP_VERB_HEAD("HEAD");
+const std::string HTTP_VERB_GET("GET");
+const std::string HTTP_VERB_PUT("PUT");
+const std::string HTTP_VERB_POST("POST");
+const std::string HTTP_VERB_DELETE("DELETE");
+const std::string HTTP_VERB_MOVE("MOVE");
+const std::string HTTP_VERB_OPTIONS("OPTIONS");
+const std::string HTTP_VERB_PATCH("PATCH");
+const std::string HTTP_VERB_COPY("COPY");
diff --git a/indra/llcorehttp/llhttpconstants.h b/indra/llcorehttp/llhttpconstants.h
new file mode 100755
index 0000000000..121448854e
--- /dev/null
+++ b/indra/llcorehttp/llhttpconstants.h
@@ -0,0 +1,219 @@
+/** 
+ * @file llhttpconstants.h
+ * @brief Constants for HTTP requests and responses
+ *
+ * $LicenseInfo:firstyear=2001&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2001-2014, 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_HTTP_CONSTANTS_H
+#define LL_HTTP_CONSTANTS_H
+
+#include "stdtypes.h"
+
+/////// HTTP STATUS CODES ///////
+
+// Standard errors from HTTP spec:
+// http://www.w3.org/Protocols/rfc2616/rfc2616-sec6.html#sec6.1
+const S32 HTTP_CONTINUE = 100;
+const S32 HTTP_SWITCHING_PROTOCOLS = 101;
+
+// Success
+const S32 HTTP_OK = 200;
+const S32 HTTP_CREATED = 201;
+const S32 HTTP_ACCEPTED = 202;
+const S32 HTTP_NON_AUTHORITATIVE_INFORMATION = 203;
+const S32 HTTP_NO_CONTENT = 204;
+const S32 HTTP_RESET_CONTENT = 205;
+const S32 HTTP_PARTIAL_CONTENT = 206;
+
+// Redirection
+const S32 HTTP_MULTIPLE_CHOICES = 300;
+const S32 HTTP_MOVED_PERMANENTLY = 301;
+const S32 HTTP_FOUND = 302;
+const S32 HTTP_SEE_OTHER = 303;
+const S32 HTTP_NOT_MODIFIED = 304;
+const S32 HTTP_USE_PROXY = 305;
+const S32 HTTP_TEMPORARY_REDIRECT = 307;
+
+// Client Error
+const S32 HTTP_BAD_REQUEST = 400;
+const S32 HTTP_UNAUTHORIZED = 401;
+const S32 HTTP_PAYMENT_REQUIRED = 402;
+const S32 HTTP_FORBIDDEN = 403;
+const S32 HTTP_NOT_FOUND = 404;
+const S32 HTTP_METHOD_NOT_ALLOWED = 405;
+const S32 HTTP_NOT_ACCEPTABLE = 406;
+const S32 HTTP_PROXY_AUTHENTICATION_REQUIRED = 407;
+const S32 HTTP_REQUEST_TIME_OUT = 408;
+const S32 HTTP_CONFLICT = 409;
+const S32 HTTP_GONE = 410;
+const S32 HTTP_LENGTH_REQUIRED = 411;
+const S32 HTTP_PRECONDITION_FAILED = 412;
+const S32 HTTP_REQUEST_ENTITY_TOO_LARGE = 413;
+const S32 HTTP_REQUEST_URI_TOO_LARGE = 414;
+const S32 HTTP_UNSUPPORTED_MEDIA_TYPE = 415;
+const S32 HTTP_REQUESTED_RANGE_NOT_SATISFIABLE = 416;
+const S32 HTTP_EXPECTATION_FAILED = 417;
+
+// Server Error
+const S32 HTTP_INTERNAL_SERVER_ERROR = 500;
+const S32 HTTP_NOT_IMPLEMENTED = 501;
+const S32 HTTP_BAD_GATEWAY = 502;
+const S32 HTTP_SERVICE_UNAVAILABLE = 503;
+const S32 HTTP_GATEWAY_TIME_OUT = 504;
+const S32 HTTP_VERSION_NOT_SUPPORTED = 505;
+
+// We combine internal process errors with status codes
+// These status codes should not be sent over the wire
+//   and indicate something went wrong internally.
+// If you get these they are not normal.
+const S32 HTTP_INTERNAL_CURL_ERROR = 498;
+const S32 HTTP_INTERNAL_ERROR = 499;
+
+
+////// HTTP Methods //////
+
+extern const std::string HTTP_VERB_INVALID;
+extern const std::string HTTP_VERB_HEAD;
+extern const std::string HTTP_VERB_GET;
+extern const std::string HTTP_VERB_PUT;
+extern const std::string HTTP_VERB_POST;
+extern const std::string HTTP_VERB_DELETE;
+extern const std::string HTTP_VERB_MOVE;
+extern const std::string HTTP_VERB_OPTIONS;
+
+enum EHTTPMethod
+{
+	HTTP_INVALID = 0,
+	HTTP_HEAD,
+	HTTP_GET,
+	HTTP_PUT,
+	HTTP_POST,
+	HTTP_DELETE,
+	HTTP_MOVE, // Caller will need to set 'Destination' header
+	HTTP_OPTIONS,
+	HTTP_PATCH,
+	HTTP_COPY,
+	HTTP_METHOD_COUNT
+};
+
+// Parses 'Retry-After' header contents and returns seconds until retry should occur.
+bool getSecondsUntilRetryAfter(const std::string& retry_after, F32& seconds_to_wait);
+
+//// HTTP Headers /////
+
+// Outgoing headers. Do *not* use these to check incoming headers.
+// For incoming headers, use the lower-case headers, below.
+extern const std::string HTTP_OUT_HEADER_ACCEPT;
+extern const std::string HTTP_OUT_HEADER_ACCEPT_CHARSET;
+extern const std::string HTTP_OUT_HEADER_ACCEPT_ENCODING;
+extern const std::string HTTP_OUT_HEADER_ACCEPT_LANGUAGE;
+extern const std::string HTTP_OUT_HEADER_ACCEPT_RANGES;
+extern const std::string HTTP_OUT_HEADER_AGE;
+extern const std::string HTTP_OUT_HEADER_ALLOW;
+extern const std::string HTTP_OUT_HEADER_AUTHORIZATION;
+extern const std::string HTTP_OUT_HEADER_CACHE_CONTROL;
+extern const std::string HTTP_OUT_HEADER_CONNECTION;
+extern const std::string HTTP_OUT_HEADER_CONTENT_DESCRIPTION;
+extern const std::string HTTP_OUT_HEADER_CONTENT_ENCODING;
+extern const std::string HTTP_OUT_HEADER_CONTENT_ID;
+extern const std::string HTTP_OUT_HEADER_CONTENT_LANGUAGE;
+extern const std::string HTTP_OUT_HEADER_CONTENT_LENGTH;
+extern const std::string HTTP_OUT_HEADER_CONTENT_LOCATION;
+extern const std::string HTTP_OUT_HEADER_CONTENT_MD5;
+extern const std::string HTTP_OUT_HEADER_CONTENT_RANGE;
+extern const std::string HTTP_OUT_HEADER_CONTENT_TRANSFER_ENCODING;
+extern const std::string HTTP_OUT_HEADER_CONTENT_TYPE;
+extern const std::string HTTP_OUT_HEADER_COOKIE;
+extern const std::string HTTP_OUT_HEADER_DATE;
+extern const std::string HTTP_OUT_HEADER_DESTINATION;
+extern const std::string HTTP_OUT_HEADER_ETAG;
+extern const std::string HTTP_OUT_HEADER_EXPECT;
+extern const std::string HTTP_OUT_HEADER_EXPIRES;
+extern const std::string HTTP_OUT_HEADER_FROM;
+extern const std::string HTTP_OUT_HEADER_HOST;
+extern const std::string HTTP_OUT_HEADER_IF_MATCH;
+extern const std::string HTTP_OUT_HEADER_IF_MODIFIED_SINCE;
+extern const std::string HTTP_OUT_HEADER_IF_NONE_MATCH;
+extern const std::string HTTP_OUT_HEADER_IF_RANGE;
+extern const std::string HTTP_OUT_HEADER_IF_UNMODIFIED_SINCE;
+extern const std::string HTTP_OUT_HEADER_KEEP_ALIVE;
+extern const std::string HTTP_OUT_HEADER_LAST_MODIFIED;
+extern const std::string HTTP_OUT_HEADER_LOCATION;
+extern const std::string HTTP_OUT_HEADER_MAX_FORWARDS;
+extern const std::string HTTP_OUT_HEADER_MIME_VERSION;
+extern const std::string HTTP_OUT_HEADER_PRAGMA;
+extern const std::string HTTP_OUT_HEADER_PROXY_AUTHENTICATE;
+extern const std::string HTTP_OUT_HEADER_PROXY_AUTHORIZATION;
+extern const std::string HTTP_OUT_HEADER_RANGE;
+extern const std::string HTTP_OUT_HEADER_REFERER;
+extern const std::string HTTP_OUT_HEADER_RETRY_AFTER;
+extern const std::string HTTP_OUT_HEADER_SERVER;
+extern const std::string HTTP_OUT_HEADER_SET_COOKIE;
+extern const std::string HTTP_OUT_HEADER_TE;
+extern const std::string HTTP_OUT_HEADER_TRAILER;
+extern const std::string HTTP_OUT_HEADER_TRANSFER_ENCODING;
+extern const std::string HTTP_OUT_HEADER_UPGRADE;
+extern const std::string HTTP_OUT_HEADER_USER_AGENT;
+extern const std::string HTTP_OUT_HEADER_VARY;
+extern const std::string HTTP_OUT_HEADER_VIA;
+extern const std::string HTTP_OUT_HEADER_WARNING;
+extern const std::string HTTP_OUT_HEADER_WWW_AUTHENTICATE;
+
+// Incoming headers are normalized to lower-case.
+extern const std::string HTTP_IN_HEADER_ACCEPT_LANGUAGE;
+extern const std::string HTTP_IN_HEADER_CACHE_CONTROL;
+extern const std::string HTTP_IN_HEADER_CONTENT_LENGTH;
+extern const std::string HTTP_IN_HEADER_CONTENT_LOCATION;
+extern const std::string HTTP_IN_HEADER_CONTENT_TYPE;
+extern const std::string HTTP_IN_HEADER_HOST;
+extern const std::string HTTP_IN_HEADER_LOCATION;
+extern const std::string HTTP_IN_HEADER_RETRY_AFTER;
+extern const std::string HTTP_IN_HEADER_SET_COOKIE;
+extern const std::string HTTP_IN_HEADER_USER_AGENT;
+extern const std::string HTTP_IN_HEADER_X_FORWARDED_FOR;
+
+//// HTTP Content Types ////
+
+extern const std::string HTTP_CONTENT_LLSD_XML;
+extern const std::string HTTP_CONTENT_OCTET_STREAM;
+extern const std::string HTTP_CONTENT_VND_LL_MESH;
+extern const std::string HTTP_CONTENT_XML;
+extern const std::string HTTP_CONTENT_JSON;
+extern const std::string HTTP_CONTENT_TEXT_HTML;
+extern const std::string HTTP_CONTENT_TEXT_HTML_UTF8;
+extern const std::string HTTP_CONTENT_TEXT_PLAIN_UTF8;
+extern const std::string HTTP_CONTENT_TEXT_LLSD;
+extern const std::string HTTP_CONTENT_TEXT_XML;
+extern const std::string HTTP_CONTENT_TEXT_LSL;
+extern const std::string HTTP_CONTENT_TEXT_PLAIN;
+extern const std::string HTTP_CONTENT_IMAGE_X_J2C;
+extern const std::string HTTP_CONTENT_IMAGE_J2C;
+extern const std::string HTTP_CONTENT_IMAGE_JPEG;
+extern const std::string HTTP_CONTENT_IMAGE_PNG;
+extern const std::string HTTP_CONTENT_IMAGE_BMP;
+
+//// HTTP Cache Settings ////
+extern const std::string HTTP_NO_CACHE;
+extern const std::string HTTP_NO_CACHE_CONTROL;
+
+#endif
diff --git a/indra/llcrashlogger/llcrashlogger.cpp b/indra/llcrashlogger/llcrashlogger.cpp
index 4caf6dcd05..6fd4579876 100755
--- a/indra/llcrashlogger/llcrashlogger.cpp
+++ b/indra/llcrashlogger/llcrashlogger.cpp
@@ -214,11 +214,13 @@ void LLCrashLogger::gatherFiles()
 		mFileMap["SettingsXml"] = mDebugLog["SettingsFilename"].asString();
 		if(mDebugLog.has("CAFilename"))
 		{
-			LLCurl::setCAFile(mDebugLog["CAFilename"].asString());
+            LLCore::HttpRequest::setStaticPolicyOption(LLCore::HttpRequest::PO_CA_FILE,
+                LLCore::HttpRequest::GLOBAL_POLICY_ID, mDebugLog["CAFilename"].asString(), NULL);
 		}
 		else
 		{
-			LLCurl::setCAFile(gDirUtilp->getCAFile());
+            LLCore::HttpRequest::setStaticPolicyOption(LLCore::HttpRequest::PO_CA_FILE,
+                LLCore::HttpRequest::GLOBAL_POLICY_ID, gDirUtilp->getCAFile(), NULL);
 		}
 
 		LL_INFOS() << "Using log file from debug log " << mFileMap["SecondLifeLog"] << LL_ENDL;
@@ -227,7 +229,8 @@ void LLCrashLogger::gatherFiles()
 	else
 	{
 		// Figure out the filename of the second life log
-		LLCurl::setCAFile(gDirUtilp->getCAFile());
+        LLCore::HttpRequest::setStaticPolicyOption(LLCore::HttpRequest::PO_CA_FILE,
+            LLCore::HttpRequest::GLOBAL_POLICY_ID, gDirUtilp->getCAFile(), NULL);
         
 		mFileMap["SecondLifeLog"] = gDirUtilp->getExpandedFilename(LL_PATH_DUMP,"SecondLife.log");
         mFileMap["SettingsXml"] = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS,"settings.xml");
@@ -531,7 +534,7 @@ void LLCrashLogger::updateApplication(const std::string& message)
 
 bool LLCrashLogger::init()
 {
-	LLCurl::initClass(false);
+    LLCore::LLHttp::initialize();
 
 	// We assume that all the logs we're looking for reside on the current drive
 	gDirUtilp->initAppDirs("SecondLife");
diff --git a/indra/llmessage/CMakeLists.txt b/indra/llmessage/CMakeLists.txt
index 9cbb76e794..3bcee13d28 100755
--- a/indra/llmessage/CMakeLists.txt
+++ b/indra/llmessage/CMakeLists.txt
@@ -42,13 +42,11 @@ set(llmessage_SOURCE_FILES
     llclassifiedflags.cpp
     llcoproceduremanager.cpp
     llcorehttputil.cpp
-    llcurl.cpp
     lldatapacker.cpp
     lldispatcher.cpp
     llexperiencecache.cpp
     llfiltersd2xmlrpc.cpp
     llhost.cpp
-    llhttpconstants.cpp
     llhttpnode.cpp
     llhttpsdhandler.cpp
     llinstantmessage.cpp
@@ -126,7 +124,6 @@ set(llmessage_HEADER_FILES
     llclassifiedflags.h
     llcoproceduremanager.h
     llcorehttputil.h
-    llcurl.h
     lldatapacker.h
     lldbstrings.h
     lldispatcher.h
@@ -136,7 +133,6 @@ set(llmessage_HEADER_FILES
     llfiltersd2xmlrpc.h
     llfollowcamparams.h
     llhost.h
-    llhttpconstants.h
     llhttpnode.h
     llhttpnodeadapter.h
     llhttpsdhandler.h
diff --git a/indra/llmessage/llcurl.cpp b/indra/llmessage/llcurl.cpp
deleted file mode 100755
index 0094c42a02..0000000000
--- a/indra/llmessage/llcurl.cpp
+++ /dev/null
@@ -1,360 +0,0 @@
-/**
- * @file llcurl.cpp
- * @author Zero / Donovan
- * @date 2006-10-15
- * @brief Implementation of wrapper around libcurl.
- *
- * $LicenseInfo:firstyear=2006&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010-2013, 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$
- */
-
-#if LL_WINDOWS
-#define SAFE_SSL 1
-#elif LL_DARWIN
-#define SAFE_SSL 1
-#else
-#define SAFE_SSL 1
-#endif
-
-#include "linden_common.h"
-
-#include "llcurl.h"
-
-#include <algorithm>
-#include <iomanip>
-#include <curl/curl.h>
-#if SAFE_SSL
-#include <openssl/crypto.h>
-#endif
-
-#include "llbufferstream.h"
-#include "llproxy.h"
-#include "llsdserialize.h"
-#include "llstl.h"
-#include "llstring.h"
-#include "llthread.h"
-#include "lltimer.h"
-
-//////////////////////////////////////////////////////////////////////////////
-/*
-	The trick to getting curl to do keep-alives is to reuse the
-	same easy handle for the requests.  It appears that curl
-	keeps a pool of connections alive for each easy handle, but
-	doesn't share them between easy handles.  Therefore it is
-	important to keep a pool of easy handles and reuse them,
-	rather than create and destroy them with each request.  This
-	code does this.
-
-	Furthermore, it would behoove us to keep track of which
-	hosts an easy handle was used for and pick an easy handle
-	that matches the next request.  This code does not current
-	do this.
- */
-
-// *TODO: TSN remove the commented code from this file
-//////////////////////////////////////////////////////////////////////////////
-
-//static const S32 MAX_ACTIVE_REQUEST_COUNT = 100;
-
-// DEBUG //
-S32 gCurlEasyCount = 0;
-S32 gCurlMultiCount = 0;
-
-//////////////////////////////////////////////////////////////////////////////
-
-//static
-std::vector<LLMutex*> LLCurl::sSSLMutex;
-std::string LLCurl::sCAPath;
-std::string LLCurl::sCAFile;
-//LLCurlThread* LLCurl::sCurlThread = NULL ;
-LLMutex* LLCurl::sHandleMutexp = NULL ;
-S32      LLCurl::sTotalHandles = 0 ;
-bool     LLCurl::sNotQuitting = true;
-F32      LLCurl::sCurlRequestTimeOut = 120.f; //seonds
-S32      LLCurl::sMaxHandles = 256; //max number of handles, (multi handles and easy handles combined).
-CURL*	 LLCurl::sCurlTemplateStandardHandle = NULL;
-
-void check_curl_code(CURLcode code)
-{
-	if (code != CURLE_OK)
-	{
-		// linux appears to throw a curl error once per session for a bad initialization
-		// at a pretty random time (when enabling cookies).
-		LL_WARNS("curl") << "curl error detected: " << curl_easy_strerror(code) << LL_ENDL;
-	}
-}
-
-void check_curl_multi_code(CURLMcode code) 
-{
-	if (code != CURLM_OK)
-	{
-		// linux appears to throw a curl error once per session for a bad initialization
-		// at a pretty random time (when enabling cookies).
-		LL_WARNS("curl") << "curl multi error detected: " << curl_multi_strerror(code) << LL_ENDL;
-	}
-}
-
-//static
-void LLCurl::setCAPath(const std::string& path)
-{
-	sCAPath = path;
-}
-
-//static
-void LLCurl::setCAFile(const std::string& file)
-{
-	sCAFile = file;
-}
-
-//static
-std::string LLCurl::getVersionString()
-{
-	return std::string(curl_version());
-}
-
-
-//static
-std::string LLCurl::strerror(CURLcode errorcode)
-{
-	return std::string(curl_easy_strerror(errorcode));
-}
-
-
-////////////////////////////////////////////////////////////////////////////
-
-#if SAFE_SSL
-//static
-void LLCurl::ssl_locking_callback(int mode, int type, const char *file, int line)
-{
-	if (mode & CRYPTO_LOCK)
-	{
-		LLCurl::sSSLMutex[type]->lock();
-	}
-	else
-	{
-		LLCurl::sSSLMutex[type]->unlock();
-	}
-}
-
-//static
-unsigned long LLCurl::ssl_thread_id(void)
-{
-	return LLThread::currentID();
-}
-#endif
-
-void LLCurl::initClass(F32 curl_reuest_timeout, S32 max_number_handles, bool multi_threaded)
-{
-	sCurlRequestTimeOut = curl_reuest_timeout ; //seconds
-	sMaxHandles = max_number_handles ; //max number of handles, (multi handles and easy handles combined).
-
-	// Do not change this "unless you are familiar with and mean to control 
-	// internal operations of libcurl"
-	// - http://curl.haxx.se/libcurl/c/curl_global_init.html
-	CURLcode code = curl_global_init(CURL_GLOBAL_ALL);
-
-	check_curl_code(code);
-	
-#if SAFE_SSL
-	S32 mutex_count = CRYPTO_num_locks();
-	for (S32 i=0; i<mutex_count; i++)
-	{
-		sSSLMutex.push_back(new LLMutex(NULL));
-	}
-	CRYPTO_set_id_callback(&LLCurl::ssl_thread_id);
-	CRYPTO_set_locking_callback(&LLCurl::ssl_locking_callback);
-#endif
-
-//	sCurlThread = new LLCurlThread(multi_threaded) ;
-	if(multi_threaded)
-	{
-		sHandleMutexp = new LLMutex(NULL) ;
-//		Easy::sHandleMutexp = new LLMutex(NULL) ;
-	}
-}
-
-void LLCurl::cleanupClass()
-{
-	sNotQuitting = false; //set quitting
-
-	//shut down curl thread
-// 	while(1)
-// 	{
-// 		if(!sCurlThread->update(1)) //finish all tasks
-// 		{
-// 			break ;
-// 		}
-// 	}
-	LL_CHECK_MEMORY
-//	sCurlThread->shutdown() ;
-	LL_CHECK_MEMORY
-//	delete sCurlThread ;
-//	sCurlThread = NULL ;
-	LL_CHECK_MEMORY
-
-#if SAFE_SSL
-	CRYPTO_set_locking_callback(NULL);
-	for_each(sSSLMutex.begin(), sSSLMutex.end(), DeletePointer());
-	sSSLMutex.clear();
-#endif
-	
-    LL_CHECK_MEMORY
-
-	// Free the template easy handle
-	curl_easy_cleanup(sCurlTemplateStandardHandle);
-	sCurlTemplateStandardHandle = NULL;
-	LL_CHECK_MEMORY
-
-
-	delete sHandleMutexp ;
-	sHandleMutexp = NULL ;
-
-	LL_CHECK_MEMORY
-
-	// removed as per https://jira.secondlife.com/browse/SH-3115
-	//llassert(Easy::sActiveHandles.empty());
-}
-
-//static 
-CURLM* LLCurl::newMultiHandle()
-{
-	llassert(sNotQuitting);
-
-	LLMutexLock lock(sHandleMutexp) ;
-
-	if(sTotalHandles + 1 > sMaxHandles)
-	{
-		LL_WARNS() << "no more handles available." << LL_ENDL ;
-		return NULL ; //failed
-	}
-	sTotalHandles++;
-
-	CURLM* ret = curl_multi_init() ;
-	if(!ret)
-	{
-		LL_WARNS() << "curl_multi_init failed." << LL_ENDL ;
-	}
-
-	return ret ;
-}
-
-//static 
-CURLMcode  LLCurl::deleteMultiHandle(CURLM* handle)
-{
-	if(handle)
-	{
-		LLMutexLock lock(sHandleMutexp) ;		
-		sTotalHandles-- ;
-		return curl_multi_cleanup(handle) ;
-	}
-	return CURLM_OK ;
-}
-
-//static 
-CURL*  LLCurl::newEasyHandle()
-{
-	llassert(sNotQuitting);
-	LLMutexLock lock(sHandleMutexp) ;
-
-	if(sTotalHandles + 1 > sMaxHandles)
-	{
-		LL_WARNS() << "no more handles available." << LL_ENDL ;
-		return NULL ; //failed
-	}
-	sTotalHandles++;
-
-	CURL* ret = createStandardCurlHandle();
-	if(!ret)
-	{
-		LL_WARNS() << "failed to create curl handle." << LL_ENDL ;
-	}
-
-	return ret ;
-}
-
-//static 
-void  LLCurl::deleteEasyHandle(CURL* handle)
-{
-	if(handle)
-	{
-		LLMutexLock lock(sHandleMutexp) ;
-		LL_CHECK_MEMORY
-		curl_easy_cleanup(handle) ;
-		LL_CHECK_MEMORY
-		sTotalHandles-- ;
-	}
-}
-
-const unsigned int LLCurl::MAX_REDIRECTS = 5;
-
-// Provide access to LLCurl free functions outside of llcurl.cpp without polluting the global namespace.
-void LLCurlFF::check_easy_code(CURLcode code)
-{
-	check_curl_code(code);
-}
-// void LLCurlFF::check_multi_code(CURLMcode code)
-// {
-// 	check_curl_multi_code(code);
-// }
-
-
-// Static
-CURL* LLCurl::createStandardCurlHandle()
-{
-	if (sCurlTemplateStandardHandle == NULL)
-	{	// Late creation of the template curl handle
-		sCurlTemplateStandardHandle = curl_easy_init();
-		if (sCurlTemplateStandardHandle == NULL)
-		{
-			LL_WARNS() << "curl error calling curl_easy_init()" << LL_ENDL;
-		}
-		else
-		{
-			CURLcode result = curl_easy_setopt(sCurlTemplateStandardHandle, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
-			check_curl_code(result);
-			result = curl_easy_setopt(sCurlTemplateStandardHandle, CURLOPT_NOSIGNAL, 1);
-			check_curl_code(result);
-			result = curl_easy_setopt(sCurlTemplateStandardHandle, CURLOPT_NOPROGRESS, 1);
-			check_curl_code(result);
-			result = curl_easy_setopt(sCurlTemplateStandardHandle, CURLOPT_ENCODING, "");	
-			check_curl_code(result);
-			result = curl_easy_setopt(sCurlTemplateStandardHandle, CURLOPT_AUTOREFERER, 1);
-			check_curl_code(result);
-			result = curl_easy_setopt(sCurlTemplateStandardHandle, CURLOPT_FOLLOWLOCATION, 1);	
-			check_curl_code(result);
-			result = curl_easy_setopt(sCurlTemplateStandardHandle, CURLOPT_SSL_VERIFYPEER, 1);
-			check_curl_code(result);
-			result = curl_easy_setopt(sCurlTemplateStandardHandle, CURLOPT_SSL_VERIFYHOST, 0);
-			check_curl_code(result);
-
-			// The Linksys WRT54G V5 router has an issue with frequent
-			// DNS lookups from LAN machines.  If they happen too often,
-			// like for every HTTP request, the router gets annoyed after
-			// about 700 or so requests and starts issuing TCP RSTs to
-			// new connections.  Reuse the DNS lookups for even a few
-			// seconds and no RSTs.
-			result = curl_easy_setopt(sCurlTemplateStandardHandle, CURLOPT_DNS_CACHE_TIMEOUT, 15);
-			check_curl_code(result);
-		}
-	}
-
-	return curl_easy_duphandle(sCurlTemplateStandardHandle);
-}
diff --git a/indra/llmessage/llcurl.h b/indra/llmessage/llcurl.h
deleted file mode 100755
index 289e4bfd22..0000000000
--- a/indra/llmessage/llcurl.h
+++ /dev/null
@@ -1,142 +0,0 @@
-/** 
- * @file llcurl.h
- * @author Zero / Donovan
- * @date 2006-10-15
- * @brief A wrapper around libcurl.
- *
- * $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_LLCURL_H
-#define LL_LLCURL_H
-
-#include "linden_common.h"
-
-#include <sstream>
-#include <string>
-#include <vector>
-
-#include <boost/intrusive_ptr.hpp>
-#include <curl/curl.h> // TODO: remove dependency
-
-#include "llbuffer.h"
-#include "llhttpconstants.h"
-#include "lliopipe.h"
-#include "llsd.h"
-#include "llqueuedthread.h"
-#include "llframetimer.h"
-#include "llpointer.h"
-#include "llsingleton.h"
-
-class LLMutex;
-//class LLCurlThread;
-
-// For whatever reason, this is not typedef'd in curl.h
-typedef size_t (*curl_header_callback)(void *ptr, size_t size, size_t nmemb, void *stream);
-
-class LLCurl
-{
-	LOG_CLASS(LLCurl);
-	
-public:
-
-	/**
-	 * @ brief Set certificate authority file used to verify HTTPS certs.
-	 */
-	static void setCAFile(const std::string& file);
-
-	/**
-	 * @ brief Set certificate authority path used to verify HTTPS certs.
-	 */
-	static void setCAPath(const std::string& path);
-
-	/**
-	 * @ brief Return human-readable string describing libcurl version.
-	 */
-	static std::string getVersionString();
-	
-	/**
-	 * @ brief Get certificate authority file used to verify HTTPS certs.
-	 */
-	static const std::string& getCAFile() { return sCAFile; }
-
-	/**
-	 * @ brief Get certificate authority path used to verify HTTPS certs.
-	 */
-	static const std::string& getCAPath() { return sCAPath; }
-
-	/**
-	 * @ brief Initialize LLCurl class
-	 */
-	static void initClass(F32 curl_reuest_timeout = 120.f, S32 max_number_handles = 256, bool multi_threaded = false);
-
-	/**
-	 * @ brief Cleanup LLCurl class
-	 */
-	static void cleanupClass();
-
-	/**
-	 * @ brief curl error code -> string
-	 */
-	static std::string strerror(CURLcode errorcode);
-	
-	// For OpenSSL callbacks
-	static std::vector<LLMutex*> sSSLMutex;
-
-	// OpenSSL callbacks
-	static void ssl_locking_callback(int mode, int type, const char *file, int line);
-	static unsigned long ssl_thread_id(void);
-
-//	static LLCurlThread* getCurlThread() { return sCurlThread ;}
-
-	static CURLM* newMultiHandle() ;
-	static CURLMcode deleteMultiHandle(CURLM* handle) ;
-	static CURL*  newEasyHandle() ;
-	static void   deleteEasyHandle(CURL* handle) ;
-
-	static CURL*	createStandardCurlHandle();
-
-private:
-	static std::string sCAPath;
-	static std::string sCAFile;
-	static const unsigned int MAX_REDIRECTS;
-    //	static LLCurlThread* sCurlThread;
-//    static LLCurlThread* sCurlThread;
-
-	static LLMutex* sHandleMutexp ;
-	static S32      sTotalHandles ;
-	static S32      sMaxHandles;
-	static CURL*	sCurlTemplateStandardHandle;
-public:
-	static bool     sNotQuitting;
-	static F32      sCurlRequestTimeOut;	
-};
-
-
-// Provide access to LLCurl free functions outside of llcurl.cpp without polluting the global namespace.
-namespace LLCurlFF
-{
-	void check_easy_code(CURLcode code);
-	//void check_multi_code(CURLMcode code);
-}
-
-#endif // LL_LLCURL_H
diff --git a/indra/llmessage/llhttpconstants.cpp b/indra/llmessage/llhttpconstants.cpp
deleted file mode 100755
index 32f76f0d70..0000000000
--- a/indra/llmessage/llhttpconstants.cpp
+++ /dev/null
@@ -1,226 +0,0 @@
-/** 
- * @file llhttpconstants.cpp
- * @brief Implementation of the HTTP request / response constant lookups
- *
- * $LicenseInfo:firstyear=2013&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2013-2014, 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 "llhttpconstants.h"
-#include "lltimer.h"
-
-// for curl_getdate() (apparently parsing RFC 1123 dates is hard)
-#include <curl/curl.h>
-
-// Outgoing headers. Do *not* use these to check incoming headers.
-// For incoming headers, use the lower-case headers, below.
-const std::string HTTP_OUT_HEADER_ACCEPT("Accept");
-const std::string HTTP_OUT_HEADER_ACCEPT_CHARSET("Accept-Charset");
-const std::string HTTP_OUT_HEADER_ACCEPT_ENCODING("Accept-Encoding");
-const std::string HTTP_OUT_HEADER_ACCEPT_LANGUAGE("Accept-Language");
-const std::string HTTP_OUT_HEADER_ACCEPT_RANGES("Accept-Ranges");
-const std::string HTTP_OUT_HEADER_AGE("Age");
-const std::string HTTP_OUT_HEADER_ALLOW("Allow");
-const std::string HTTP_OUT_HEADER_AUTHORIZATION("Authorization");
-const std::string HTTP_OUT_HEADER_CACHE_CONTROL("Cache-Control");
-const std::string HTTP_OUT_HEADER_CONNECTION("Connection");
-const std::string HTTP_OUT_HEADER_CONTENT_DESCRIPTION("Content-Description");
-const std::string HTTP_OUT_HEADER_CONTENT_ENCODING("Content-Encoding");
-const std::string HTTP_OUT_HEADER_CONTENT_ID("Content-ID");
-const std::string HTTP_OUT_HEADER_CONTENT_LANGUAGE("Content-Language");
-const std::string HTTP_OUT_HEADER_CONTENT_LENGTH("Content-Length");
-const std::string HTTP_OUT_HEADER_CONTENT_LOCATION("Content-Location");
-const std::string HTTP_OUT_HEADER_CONTENT_MD5("Content-MD5");
-const std::string HTTP_OUT_HEADER_CONTENT_RANGE("Content-Range");
-const std::string HTTP_OUT_HEADER_CONTENT_TRANSFER_ENCODING("Content-Transfer-Encoding");
-const std::string HTTP_OUT_HEADER_CONTENT_TYPE("Content-Type");
-const std::string HTTP_OUT_HEADER_COOKIE("Cookie");
-const std::string HTTP_OUT_HEADER_DATE("Date");
-const std::string HTTP_OUT_HEADER_DESTINATION("Destination");
-const std::string HTTP_OUT_HEADER_ETAG("ETag");
-const std::string HTTP_OUT_HEADER_EXPECT("Expect");
-const std::string HTTP_OUT_HEADER_EXPIRES("Expires");
-const std::string HTTP_OUT_HEADER_FROM("From");
-const std::string HTTP_OUT_HEADER_HOST("Host");
-const std::string HTTP_OUT_HEADER_IF_MATCH("If-Match");
-const std::string HTTP_OUT_HEADER_IF_MODIFIED_SINCE("If-Modified-Since");
-const std::string HTTP_OUT_HEADER_IF_NONE_MATCH("If-None-Match");
-const std::string HTTP_OUT_HEADER_IF_RANGE("If-Range");
-const std::string HTTP_OUT_HEADER_IF_UNMODIFIED_SINCE("If-Unmodified-Since");
-const std::string HTTP_OUT_HEADER_KEEP_ALIVE("Keep-Alive");
-const std::string HTTP_OUT_HEADER_LAST_MODIFIED("Last-Modified");
-const std::string HTTP_OUT_HEADER_LOCATION("Location");
-const std::string HTTP_OUT_HEADER_MAX_FORWARDS("Max-Forwards");
-const std::string HTTP_OUT_HEADER_MIME_VERSION("MIME-Version");
-const std::string HTTP_OUT_HEADER_PRAGMA("Pragma");
-const std::string HTTP_OUT_HEADER_PROXY_AUTHENTICATE("Proxy-Authenticate");
-const std::string HTTP_OUT_HEADER_PROXY_AUTHORIZATION("Proxy-Authorization");
-const std::string HTTP_OUT_HEADER_RANGE("Range");
-const std::string HTTP_OUT_HEADER_REFERER("Referer");
-const std::string HTTP_OUT_HEADER_RETRY_AFTER("Retry-After");
-const std::string HTTP_OUT_HEADER_SERVER("Server");
-const std::string HTTP_OUT_HEADER_SET_COOKIE("Set-Cookie");
-const std::string HTTP_OUT_HEADER_TE("TE");
-const std::string HTTP_OUT_HEADER_TRAILER("Trailer");
-const std::string HTTP_OUT_HEADER_TRANSFER_ENCODING("Transfer-Encoding");
-const std::string HTTP_OUT_HEADER_UPGRADE("Upgrade");
-const std::string HTTP_OUT_HEADER_USER_AGENT("User-Agent");
-const std::string HTTP_OUT_HEADER_VARY("Vary");
-const std::string HTTP_OUT_HEADER_VIA("Via");
-const std::string HTTP_OUT_HEADER_WARNING("Warning");
-const std::string HTTP_OUT_HEADER_WWW_AUTHENTICATE("WWW-Authenticate");
-
-// Incoming headers are normalized to lower-case.
-const std::string HTTP_IN_HEADER_ACCEPT_LANGUAGE("accept-language");
-const std::string HTTP_IN_HEADER_CACHE_CONTROL("cache-control");
-const std::string HTTP_IN_HEADER_CONTENT_LENGTH("content-length");
-const std::string HTTP_IN_HEADER_CONTENT_LOCATION("content-location");
-const std::string HTTP_IN_HEADER_CONTENT_TYPE("content-type");
-const std::string HTTP_IN_HEADER_HOST("host");
-const std::string HTTP_IN_HEADER_LOCATION("location");
-const std::string HTTP_IN_HEADER_RETRY_AFTER("retry-after");
-const std::string HTTP_IN_HEADER_SET_COOKIE("set-cookie");
-const std::string HTTP_IN_HEADER_USER_AGENT("user-agent");
-const std::string HTTP_IN_HEADER_X_FORWARDED_FOR("x-forwarded-for");
-
-const std::string HTTP_CONTENT_LLSD_XML("application/llsd+xml");
-const std::string HTTP_CONTENT_OCTET_STREAM("application/octet-stream");
-const std::string HTTP_CONTENT_VND_LL_MESH("application/vnd.ll.mesh");
-const std::string HTTP_CONTENT_XML("application/xml");
-const std::string HTTP_CONTENT_JSON("application/json");
-const std::string HTTP_CONTENT_TEXT_HTML("text/html");
-const std::string HTTP_CONTENT_TEXT_HTML_UTF8("text/html; charset=utf-8");
-const std::string HTTP_CONTENT_TEXT_PLAIN_UTF8("text/plain; charset=utf-8");
-const std::string HTTP_CONTENT_TEXT_LLSD("text/llsd");
-const std::string HTTP_CONTENT_TEXT_XML("text/xml");
-const std::string HTTP_CONTENT_TEXT_LSL("text/lsl");
-const std::string HTTP_CONTENT_TEXT_PLAIN("text/plain");
-const std::string HTTP_CONTENT_IMAGE_X_J2C("image/x-j2c");
-const std::string HTTP_CONTENT_IMAGE_J2C("image/j2c");
-const std::string HTTP_CONTENT_IMAGE_JPEG("image/jpeg");
-const std::string HTTP_CONTENT_IMAGE_PNG("image/png");
-const std::string HTTP_CONTENT_IMAGE_BMP("image/bmp");
-
-const std::string HTTP_NO_CACHE("no-cache");
-const std::string HTTP_NO_CACHE_CONTROL("no-cache, max-age=0");
-
-const std::string HTTP_VERB_INVALID("(invalid)");
-const std::string HTTP_VERB_HEAD("HEAD");
-const std::string HTTP_VERB_GET("GET");
-const std::string HTTP_VERB_PUT("PUT");
-const std::string HTTP_VERB_POST("POST");
-const std::string HTTP_VERB_DELETE("DELETE");
-const std::string HTTP_VERB_MOVE("MOVE");
-const std::string HTTP_VERB_OPTIONS("OPTIONS");
-const std::string HTTP_VERB_PATCH("PATCH");
-const std::string HTTP_VERB_COPY("COPY");
-
-const std::string& httpMethodAsVerb(EHTTPMethod method)
-{
-	static const std::string VERBS[] =
-	{
-		HTTP_VERB_INVALID,
-		HTTP_VERB_HEAD,
-		HTTP_VERB_GET,
-		HTTP_VERB_PUT,
-		HTTP_VERB_POST,
-		HTTP_VERB_DELETE,
-		HTTP_VERB_MOVE,
-		HTTP_VERB_OPTIONS,
-		HTTP_VERB_PATCH,
-		HTTP_VERB_COPY
-	};
-	if(((S32)method <=0) || ((S32)method >= HTTP_METHOD_COUNT))
-	{
-		return VERBS[0];
-	}
-	return VERBS[method];
-}
-
-bool isHttpInformationalStatus(S32 status)
-{
-	// Check for status 1xx.
-	return((100 <= status) && (status < 200));
-}
-
-bool isHttpGoodStatus(S32 status)
-{
-	// Check for status 2xx.
-	return((200 <= status) && (status < 300));
-}
-
-bool isHttpRedirectStatus(S32 status)
-{
-	// Check for status 3xx.
-	return((300 <= status) && (status < 400));
-}
-
-bool isHttpClientErrorStatus(S32 status)
-{
-	// Status 499 is sometimes used for re-interpreted status 2xx errors
-	// based on body content.  Treat these as potentially retryable 'server' status errors,
-	// since we do not have enough context to know if this will always fail.
-	if (HTTP_INTERNAL_ERROR == status) return false;
-
-	// Check for status 5xx.
-	return((400 <= status) && (status < 500));
-}
-
-bool isHttpServerErrorStatus(S32 status)
-{
-	// Status 499 is sometimes used for re-interpreted status 2xx errors.
-	// Allow retry of these, since we don't have enough information in this
-	// context to know if this will always fail.
-	if (HTTP_INTERNAL_ERROR == status) return true;
-
-	// Check for status 5xx.
-	return((500 <= status) && (status < 600));
-}
-
-// Parses 'Retry-After' header contents and returns seconds until retry should occur.
-bool getSecondsUntilRetryAfter(const std::string& retry_after, F32& seconds_to_wait)
-{
-	// *TODO:  This needs testing!   Not in use yet.
-	// Examples of Retry-After headers:
-	// Retry-After: Fri, 31 Dec 1999 23:59:59 GMT
-	// Retry-After: 120
-
-	// Check for number of seconds version, first:
-	char* end = 0;
-	// Parse as double
-	double seconds = std::strtod(retry_after.c_str(), &end);
-	if ( end != 0 && *end == 0 )
-	{
-		// Successful parse
-		seconds_to_wait = (F32) seconds;
-		return true;
-	}
-
-	// Parse rfc1123 date.
-	time_t date = curl_getdate(retry_after.c_str(), NULL );
-	if (-1 == date) return false;
-
-	seconds_to_wait = (F64)date - LLTimer::getTotalSeconds();
-
-	return true;
-}
-
diff --git a/indra/llmessage/llhttpconstants.h b/indra/llmessage/llhttpconstants.h
deleted file mode 100755
index d6bcbd3c19..0000000000
--- a/indra/llmessage/llhttpconstants.h
+++ /dev/null
@@ -1,226 +0,0 @@
-/** 
- * @file llhttpconstants.h
- * @brief Constants for HTTP requests and responses
- *
- * $LicenseInfo:firstyear=2001&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2001-2014, 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_HTTP_CONSTANTS_H
-#define LL_HTTP_CONSTANTS_H
-
-#include "stdtypes.h"
-
-/////// HTTP STATUS CODES ///////
-
-// Standard errors from HTTP spec:
-// http://www.w3.org/Protocols/rfc2616/rfc2616-sec6.html#sec6.1
-const S32 HTTP_CONTINUE = 100;
-const S32 HTTP_SWITCHING_PROTOCOLS = 101;
-
-// Success
-const S32 HTTP_OK = 200;
-const S32 HTTP_CREATED = 201;
-const S32 HTTP_ACCEPTED = 202;
-const S32 HTTP_NON_AUTHORITATIVE_INFORMATION = 203;
-const S32 HTTP_NO_CONTENT = 204;
-const S32 HTTP_RESET_CONTENT = 205;
-const S32 HTTP_PARTIAL_CONTENT = 206;
-
-// Redirection
-const S32 HTTP_MULTIPLE_CHOICES = 300;
-const S32 HTTP_MOVED_PERMANENTLY = 301;
-const S32 HTTP_FOUND = 302;
-const S32 HTTP_SEE_OTHER = 303;
-const S32 HTTP_NOT_MODIFIED = 304;
-const S32 HTTP_USE_PROXY = 305;
-const S32 HTTP_TEMPORARY_REDIRECT = 307;
-
-// Client Error
-const S32 HTTP_BAD_REQUEST = 400;
-const S32 HTTP_UNAUTHORIZED = 401;
-const S32 HTTP_PAYMENT_REQUIRED = 402;
-const S32 HTTP_FORBIDDEN = 403;
-const S32 HTTP_NOT_FOUND = 404;
-const S32 HTTP_METHOD_NOT_ALLOWED = 405;
-const S32 HTTP_NOT_ACCEPTABLE = 406;
-const S32 HTTP_PROXY_AUTHENTICATION_REQUIRED = 407;
-const S32 HTTP_REQUEST_TIME_OUT = 408;
-const S32 HTTP_CONFLICT = 409;
-const S32 HTTP_GONE = 410;
-const S32 HTTP_LENGTH_REQUIRED = 411;
-const S32 HTTP_PRECONDITION_FAILED = 412;
-const S32 HTTP_REQUEST_ENTITY_TOO_LARGE = 413;
-const S32 HTTP_REQUEST_URI_TOO_LARGE = 414;
-const S32 HTTP_UNSUPPORTED_MEDIA_TYPE = 415;
-const S32 HTTP_REQUESTED_RANGE_NOT_SATISFIABLE = 416;
-const S32 HTTP_EXPECTATION_FAILED = 417;
-
-// Server Error
-const S32 HTTP_INTERNAL_SERVER_ERROR = 500;
-const S32 HTTP_NOT_IMPLEMENTED = 501;
-const S32 HTTP_BAD_GATEWAY = 502;
-const S32 HTTP_SERVICE_UNAVAILABLE = 503;
-const S32 HTTP_GATEWAY_TIME_OUT = 504;
-const S32 HTTP_VERSION_NOT_SUPPORTED = 505;
-
-// We combine internal process errors with status codes
-// These status codes should not be sent over the wire
-//   and indicate something went wrong internally.
-// If you get these they are not normal.
-const S32 HTTP_INTERNAL_CURL_ERROR = 498;
-const S32 HTTP_INTERNAL_ERROR = 499;
-
-
-////// HTTP Methods //////
-
-extern const std::string HTTP_VERB_INVALID;
-extern const std::string HTTP_VERB_HEAD;
-extern const std::string HTTP_VERB_GET;
-extern const std::string HTTP_VERB_PUT;
-extern const std::string HTTP_VERB_POST;
-extern const std::string HTTP_VERB_DELETE;
-extern const std::string HTTP_VERB_MOVE;
-extern const std::string HTTP_VERB_OPTIONS;
-
-enum EHTTPMethod
-{
-	HTTP_INVALID = 0,
-	HTTP_HEAD,
-	HTTP_GET,
-	HTTP_PUT,
-	HTTP_POST,
-	HTTP_DELETE,
-	HTTP_MOVE, // Caller will need to set 'Destination' header
-	HTTP_OPTIONS,
-	HTTP_PATCH,
-	HTTP_COPY,
-	HTTP_METHOD_COUNT
-};
-
-const std::string& httpMethodAsVerb(EHTTPMethod method);
-bool isHttpInformationalStatus(S32 status);
-bool isHttpGoodStatus(S32 status);
-bool isHttpRedirectStatus(S32 status);
-bool isHttpClientErrorStatus(S32 status);
-bool isHttpServerErrorStatus(S32 status);
-
-// Parses 'Retry-After' header contents and returns seconds until retry should occur.
-bool getSecondsUntilRetryAfter(const std::string& retry_after, F32& seconds_to_wait);
-
-//// HTTP Headers /////
-
-// Outgoing headers. Do *not* use these to check incoming headers.
-// For incoming headers, use the lower-case headers, below.
-extern const std::string HTTP_OUT_HEADER_ACCEPT;
-extern const std::string HTTP_OUT_HEADER_ACCEPT_CHARSET;
-extern const std::string HTTP_OUT_HEADER_ACCEPT_ENCODING;
-extern const std::string HTTP_OUT_HEADER_ACCEPT_LANGUAGE;
-extern const std::string HTTP_OUT_HEADER_ACCEPT_RANGES;
-extern const std::string HTTP_OUT_HEADER_AGE;
-extern const std::string HTTP_OUT_HEADER_ALLOW;
-extern const std::string HTTP_OUT_HEADER_AUTHORIZATION;
-extern const std::string HTTP_OUT_HEADER_CACHE_CONTROL;
-extern const std::string HTTP_OUT_HEADER_CONNECTION;
-extern const std::string HTTP_OUT_HEADER_CONTENT_DESCRIPTION;
-extern const std::string HTTP_OUT_HEADER_CONTENT_ENCODING;
-extern const std::string HTTP_OUT_HEADER_CONTENT_ID;
-extern const std::string HTTP_OUT_HEADER_CONTENT_LANGUAGE;
-extern const std::string HTTP_OUT_HEADER_CONTENT_LENGTH;
-extern const std::string HTTP_OUT_HEADER_CONTENT_LOCATION;
-extern const std::string HTTP_OUT_HEADER_CONTENT_MD5;
-extern const std::string HTTP_OUT_HEADER_CONTENT_RANGE;
-extern const std::string HTTP_OUT_HEADER_CONTENT_TRANSFER_ENCODING;
-extern const std::string HTTP_OUT_HEADER_CONTENT_TYPE;
-extern const std::string HTTP_OUT_HEADER_COOKIE;
-extern const std::string HTTP_OUT_HEADER_DATE;
-extern const std::string HTTP_OUT_HEADER_DESTINATION;
-extern const std::string HTTP_OUT_HEADER_ETAG;
-extern const std::string HTTP_OUT_HEADER_EXPECT;
-extern const std::string HTTP_OUT_HEADER_EXPIRES;
-extern const std::string HTTP_OUT_HEADER_FROM;
-extern const std::string HTTP_OUT_HEADER_HOST;
-extern const std::string HTTP_OUT_HEADER_IF_MATCH;
-extern const std::string HTTP_OUT_HEADER_IF_MODIFIED_SINCE;
-extern const std::string HTTP_OUT_HEADER_IF_NONE_MATCH;
-extern const std::string HTTP_OUT_HEADER_IF_RANGE;
-extern const std::string HTTP_OUT_HEADER_IF_UNMODIFIED_SINCE;
-extern const std::string HTTP_OUT_HEADER_KEEP_ALIVE;
-extern const std::string HTTP_OUT_HEADER_LAST_MODIFIED;
-extern const std::string HTTP_OUT_HEADER_LOCATION;
-extern const std::string HTTP_OUT_HEADER_MAX_FORWARDS;
-extern const std::string HTTP_OUT_HEADER_MIME_VERSION;
-extern const std::string HTTP_OUT_HEADER_PRAGMA;
-extern const std::string HTTP_OUT_HEADER_PROXY_AUTHENTICATE;
-extern const std::string HTTP_OUT_HEADER_PROXY_AUTHORIZATION;
-extern const std::string HTTP_OUT_HEADER_RANGE;
-extern const std::string HTTP_OUT_HEADER_REFERER;
-extern const std::string HTTP_OUT_HEADER_RETRY_AFTER;
-extern const std::string HTTP_OUT_HEADER_SERVER;
-extern const std::string HTTP_OUT_HEADER_SET_COOKIE;
-extern const std::string HTTP_OUT_HEADER_TE;
-extern const std::string HTTP_OUT_HEADER_TRAILER;
-extern const std::string HTTP_OUT_HEADER_TRANSFER_ENCODING;
-extern const std::string HTTP_OUT_HEADER_UPGRADE;
-extern const std::string HTTP_OUT_HEADER_USER_AGENT;
-extern const std::string HTTP_OUT_HEADER_VARY;
-extern const std::string HTTP_OUT_HEADER_VIA;
-extern const std::string HTTP_OUT_HEADER_WARNING;
-extern const std::string HTTP_OUT_HEADER_WWW_AUTHENTICATE;
-
-// Incoming headers are normalized to lower-case.
-extern const std::string HTTP_IN_HEADER_ACCEPT_LANGUAGE;
-extern const std::string HTTP_IN_HEADER_CACHE_CONTROL;
-extern const std::string HTTP_IN_HEADER_CONTENT_LENGTH;
-extern const std::string HTTP_IN_HEADER_CONTENT_LOCATION;
-extern const std::string HTTP_IN_HEADER_CONTENT_TYPE;
-extern const std::string HTTP_IN_HEADER_HOST;
-extern const std::string HTTP_IN_HEADER_LOCATION;
-extern const std::string HTTP_IN_HEADER_RETRY_AFTER;
-extern const std::string HTTP_IN_HEADER_SET_COOKIE;
-extern const std::string HTTP_IN_HEADER_USER_AGENT;
-extern const std::string HTTP_IN_HEADER_X_FORWARDED_FOR;
-
-//// HTTP Content Types ////
-
-extern const std::string HTTP_CONTENT_LLSD_XML;
-extern const std::string HTTP_CONTENT_OCTET_STREAM;
-extern const std::string HTTP_CONTENT_VND_LL_MESH;
-extern const std::string HTTP_CONTENT_XML;
-extern const std::string HTTP_CONTENT_JSON;
-extern const std::string HTTP_CONTENT_TEXT_HTML;
-extern const std::string HTTP_CONTENT_TEXT_HTML_UTF8;
-extern const std::string HTTP_CONTENT_TEXT_PLAIN_UTF8;
-extern const std::string HTTP_CONTENT_TEXT_LLSD;
-extern const std::string HTTP_CONTENT_TEXT_XML;
-extern const std::string HTTP_CONTENT_TEXT_LSL;
-extern const std::string HTTP_CONTENT_TEXT_PLAIN;
-extern const std::string HTTP_CONTENT_IMAGE_X_J2C;
-extern const std::string HTTP_CONTENT_IMAGE_J2C;
-extern const std::string HTTP_CONTENT_IMAGE_JPEG;
-extern const std::string HTTP_CONTENT_IMAGE_PNG;
-extern const std::string HTTP_CONTENT_IMAGE_BMP;
-
-//// HTTP Cache Settings ////
-extern const std::string HTTP_NO_CACHE;
-extern const std::string HTTP_NO_CACHE_CONTROL;
-
-#endif
diff --git a/indra/llmessage/llproxy.cpp b/indra/llmessage/llproxy.cpp
index c25f1ec5e5..537efa69d8 100755
--- a/indra/llmessage/llproxy.cpp
+++ b/indra/llmessage/llproxy.cpp
@@ -30,9 +30,8 @@
 
 #include <string>
 #include <curl/curl.h>
-
+#include "httpcommon.h"
 #include "llapr.h"
-#include "llcurl.h"
 #include "llhost.h"
 
 // Static class variable instances
@@ -429,21 +428,21 @@ void LLProxy::applyProxySettings(CURL* handle)
 		// Now test again to verify that the proxy wasn't disabled between the first check and the lock.
 		if (mHTTPProxyEnabled)
 		{
-			LLCurlFF::check_easy_code(curl_easy_setopt(handle, CURLOPT_PROXY, mHTTPProxy.getIPString().c_str()));
-			LLCurlFF::check_easy_code(curl_easy_setopt(handle, CURLOPT_PROXYPORT, mHTTPProxy.getPort()));
+            LLCore::LLHttp::check_curl_code(curl_easy_setopt(handle, CURLOPT_PROXY, mHTTPProxy.getIPString().c_str()), CURLOPT_PROXY);
+            LLCore::LLHttp::check_curl_code(curl_easy_setopt(handle, CURLOPT_PROXYPORT, mHTTPProxy.getPort()), CURLOPT_PROXYPORT);
 
 			if (mProxyType == LLPROXY_SOCKS)
 			{
-				LLCurlFF::check_easy_code(curl_easy_setopt(handle, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5));
+                LLCore::LLHttp::check_curl_code(curl_easy_setopt(handle, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5), CURLOPT_PROXYTYPE);
 				if (mAuthMethodSelected == METHOD_PASSWORD)
 				{
 					std::string auth_string = mSocksUsername + ":" + mSocksPassword;
-					LLCurlFF::check_easy_code(curl_easy_setopt(handle, CURLOPT_PROXYUSERPWD, auth_string.c_str()));
+                    LLCore::LLHttp::check_curl_code(curl_easy_setopt(handle, CURLOPT_PROXYUSERPWD, auth_string.c_str()), CURLOPT_PROXYUSERPWD);
 				}
 			}
 			else
 			{
-				LLCurlFF::check_easy_code(curl_easy_setopt(handle, CURLOPT_PROXYTYPE, CURLPROXY_HTTP));
+                LLCore::LLHttp::check_curl_code(curl_easy_setopt(handle, CURLOPT_PROXYTYPE, CURLPROXY_HTTP), CURLOPT_PROXYTYPE);
 			}
 		}
 	}
diff --git a/indra/llmessage/llproxy.h b/indra/llmessage/llproxy.h
index da965219fa..bd23dd39de 100755
--- a/indra/llmessage/llproxy.h
+++ b/indra/llmessage/llproxy.h
@@ -27,12 +27,12 @@
 #ifndef LL_PROXY_H
 #define LL_PROXY_H
 
-#include "llcurl.h"
 #include "llhost.h"
 #include "lliosocket.h"
 #include "llmemory.h"
 #include "llsingleton.h"
 #include "llthread.h"
+#include <curl/curl.h>
 #include <string>
 
 // SOCKS error codes returned from the StartProxy method
diff --git a/indra/llmessage/lltrustedmessageservice.cpp b/indra/llmessage/lltrustedmessageservice.cpp
index 5bd1112cfe..33944f7883 100755
--- a/indra/llmessage/lltrustedmessageservice.cpp
+++ b/indra/llmessage/lltrustedmessageservice.cpp
@@ -30,6 +30,7 @@
 #include "llhost.h"
 #include "llmessageconfig.h"
 #include "message.h"
+#include "llhttpconstants.h"
 
 
 bool LLTrustedMessageService::validate(const std::string& name, LLSD& context)
diff --git a/indra/llmessage/message.h b/indra/llmessage/message.h
index fc391da633..133db620e6 100755
--- a/indra/llmessage/message.h
+++ b/indra/llmessage/message.h
@@ -50,7 +50,6 @@
 #include "lltimer.h"
 #include "llpacketring.h"
 #include "llhost.h"
-#include "llcurl.h"
 #include "llhttpnode.h"
 //#include "llpacketack.h"
 #include "llsingleton.h"
diff --git a/indra/newview/llaisapi.h b/indra/newview/llaisapi.h
index 48c081991a..e97059014b 100755
--- a/indra/newview/llaisapi.h
+++ b/indra/newview/llaisapi.h
@@ -31,7 +31,6 @@
 #include <map>
 #include <set>
 #include <string>
-#include "llcurl.h"
 #include "llhttpretrypolicy.h"
 #include "llviewerinventory.h"
 #include "llcorehttputil.h"
diff --git a/indra/newview/llappcorehttp.cpp b/indra/newview/llappcorehttp.cpp
index 51cca273d8..91a5148e4c 100755
--- a/indra/newview/llappcorehttp.cpp
+++ b/indra/newview/llappcorehttp.cpp
@@ -138,6 +138,9 @@ LLAppCoreHttp::~LLAppCoreHttp()
 
 void LLAppCoreHttp::init()
 {
+
+    LLCore::LLHttp::initialize();
+
 	LLCore::HttpStatus status = LLCore::HttpRequest::createService();
 	if (! status)
 	{
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 45e21d9129..ba76341b69 100755
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -58,7 +58,6 @@
 #include "llviewerjoystick.h"
 #include "llallocator.h"
 #include "llares.h" 
-#include "llcurl.h"
 #include "llcalc.h"
 #include "llconversationlog.h"
 #include "lldxhardware.h"
@@ -828,12 +827,7 @@ bool LLAppViewer::init()
 	// before consumers (LLTextureFetch).
 	mAppCoreHttp.init();
 	
-    // *NOTE:Mani - LLCurl::initClass is not thread safe. 
-    // Called before threads are created.
-    LLCurl::initClass(gSavedSettings.getF32("CurlRequestTimeOut"), 
-						gSavedSettings.getS32("CurlMaximumNumberOfHandles"), 
-						gSavedSettings.getBOOL("CurlUseMultipleThreads"));
-	LL_INFOS("InitInfo") << "LLCurl initialized." << LL_ENDL ;
+	LL_INFOS("InitInfo") << "LLCore::Http initialized." << LL_ENDL ;
 
     LLMachineID::init();
 	
@@ -903,7 +897,7 @@ bool LLAppViewer::init()
 	// the libs involved in getting to a full login screen.
 	//
 	LL_INFOS("InitInfo") << "J2C Engine is: " << LLImageJ2C::getEngineInfo() << LL_ENDL;
-	LL_INFOS("InitInfo") << "libcurl version is: " << LLCurl::getVersionString() << LL_ENDL;
+	LL_INFOS("InitInfo") << "libcurl version is: " << LLCore::LLHttp::getCURLVersion() << LL_ENDL;
 
 	/////////////////////////////////////////////////
 	// OS-specific login dialogs
@@ -1313,7 +1307,6 @@ bool LLAppViewer::mainLoop()
 		
 		// Create IO Pump to use for HTTP Requests.
 		gServicePump = new LLPumpIO(gAPRPoolp);
-		LLCurl::setCAFile(gDirUtilp->getCAFile());
 		
 		// Note: this is where gLocalSpeakerMgr and gActiveSpeakerMgr used to be instantiated.
 		
@@ -3348,7 +3341,7 @@ LLSD LLAppViewer::getViewerInfo() const
 #endif
 
 	info["OPENGL_VERSION"] = (const char*)(glGetString(GL_VERSION));
-	info["LIBCURL_VERSION"] = LLCurl::getVersionString();
+	info["LIBCURL_VERSION"] = LLCore::LLHttp::getCURLVersion();
 	info["J2C_VERSION"] = LLImageJ2C::getEngineInfo();
 	bool want_fullname = true;
 	info["AUDIO_DRIVER_VERSION"] = gAudiop ? LLSD(gAudiop->getDriverName(want_fullname)) : LLSD();
diff --git a/indra/newview/llfloaterabout.cpp b/indra/newview/llfloaterabout.cpp
index 01c9416973..7bd01f6beb 100755
--- a/indra/newview/llfloaterabout.cpp
+++ b/indra/newview/llfloaterabout.cpp
@@ -48,7 +48,6 @@
 // Linden library includes
 #include "llaudioengine.h"
 #include "llbutton.h"
-#include "llcurl.h"
 #include "llglheaders.h"
 #include "llfloater.h"
 #include "llfloaterreg.h"
diff --git a/indra/newview/llhttpretrypolicy.cpp b/indra/newview/llhttpretrypolicy.cpp
index e2e151eb63..6a2daeeb90 100755
--- a/indra/newview/llhttpretrypolicy.cpp
+++ b/indra/newview/llhttpretrypolicy.cpp
@@ -25,9 +25,23 @@
  */
 
 #include "llviewerprecompiledheaders.h"
-
 #include "llhttpretrypolicy.h"
 
+namespace
+{
+    // Moved from httpconstants.h... only used in this file.
+    bool isHttpServerErrorStatus(S32 status)
+    {
+        // Status 499 is sometimes used for re-interpreted status 2xx errors.
+        // Allow retry of these, since we don't have enough information in this
+        // context to know if this will always fail.
+        if (HTTP_INTERNAL_ERROR == status) return true;
+
+        // Check for status 5xx.
+        return((500 <= status) && (status < 600));
+    }
+}
+
 LLAdaptiveRetryPolicy::LLAdaptiveRetryPolicy(F32 min_delay, F32 max_delay, F32 backoff_factor, U32 max_retries, bool retry_on_4xx):
 	mMinDelay(min_delay),
 	mMaxDelay(max_delay),
@@ -140,3 +154,34 @@ bool LLAdaptiveRetryPolicy::shouldRetry(F32& seconds_to_wait) const
 	seconds_to_wait = mShouldRetry ? (F32) mRetryTimer.getRemainingTimeF32() : F32_MAX;
 	return mShouldRetry;
 }
+
+// Moved from httpconstants.  Only used by this file.
+// Parses 'Retry-After' header contents and returns seconds until retry should occur.
+/*static*/
+bool LLAdaptiveRetryPolicy::getSecondsUntilRetryAfter(const std::string& retry_after, F32& seconds_to_wait)
+{
+    // *TODO:  This needs testing!   Not in use yet.
+    // Examples of Retry-After headers:
+    // Retry-After: Fri, 31 Dec 1999 23:59:59 GMT
+    // Retry-After: 120
+
+    // Check for number of seconds version, first:
+    char* end = 0;
+    // Parse as double
+    double seconds = std::strtod(retry_after.c_str(), &end);
+    if (end != 0 && *end == 0)
+    {
+        // Successful parse
+        seconds_to_wait = (F32)seconds;
+        return true;
+    }
+
+    // Parse rfc1123 date.
+    time_t date = curl_getdate(retry_after.c_str(), NULL);
+    if (-1 == date) return false;
+
+    seconds_to_wait = (F64)date - LLTimer::getTotalSeconds();
+
+    return true;
+}
+
diff --git a/indra/newview/llhttpretrypolicy.h b/indra/newview/llhttpretrypolicy.h
index c0cc263546..af07b4afec 100755
--- a/indra/newview/llhttpretrypolicy.h
+++ b/indra/newview/llhttpretrypolicy.h
@@ -76,6 +76,8 @@ public:
 	// virtual
 	bool shouldRetry(F32& seconds_to_wait) const;
 
+    static bool getSecondsUntilRetryAfter(const std::string& retry_after, F32& seconds_to_wait);
+
 protected:
 	void init();
 	bool getRetryAfter(const LLSD& headers, F32& retry_header_time);
diff --git a/indra/newview/llinventorymodel.h b/indra/newview/llinventorymodel.h
index e8977bc7d7..a74e3b69f4 100755
--- a/indra/newview/llinventorymodel.h
+++ b/indra/newview/llinventorymodel.h
@@ -35,7 +35,6 @@
 #include "llassettype.h"
 #include "llfoldertype.h"
 #include "llframetimer.h"
-#include "llcurl.h"
 #include "lluuid.h"
 #include "llpermissionsflags.h"
 #include "llviewerinventory.h"
diff --git a/indra/newview/llmediadataclient.cpp b/indra/newview/llmediadataclient.cpp
index b8ff76aa6d..bfd0700a2f 100755
--- a/indra/newview/llmediadataclient.cpp
+++ b/indra/newview/llmediadataclient.cpp
@@ -631,14 +631,8 @@ void LLMediaDataClient::Handler::onFailure(LLCore::HttpResponse * response, LLCo
     if (status == LLCore::HttpStatus(HTTP_SERVICE_UNAVAILABLE))
     {
         F32 retry_timeout;
-#if 0
-        // *TODO: Honor server Retry-After header.
-        if (!hasResponseHeader(HTTP_IN_HEADER_RETRY_AFTER)
-            || !getSecondsUntilRetryAfter(getResponseHeader(HTTP_IN_HEADER_RETRY_AFTER), retry_timeout))
-#endif
-        {
-            retry_timeout = mRequest->getRetryTimerDelay();
-        }
+
+        retry_timeout = mRequest->getRetryTimerDelay();
 
         mRequest->incRetryCount();
 
diff --git a/indra/newview/llmeshrepository.cpp b/indra/newview/llmeshrepository.cpp
index 5bd9df54e2..40de31b9af 100755
--- a/indra/newview/llmeshrepository.cpp
+++ b/indra/newview/llmeshrepository.cpp
@@ -36,7 +36,6 @@
 #include "llappviewer.h"
 #include "llbufferstream.h"
 #include "llcallbacklist.h"
-#include "llcurl.h"
 #include "lldatapacker.h"
 #include "lldeadmantimer.h"
 #include "llfloatermodelpreview.h"
diff --git a/indra/newview/llpanellogin.cpp b/indra/newview/llpanellogin.cpp
index f972b320c3..bd23478694 100755
--- a/indra/newview/llpanellogin.cpp
+++ b/indra/newview/llpanellogin.cpp
@@ -40,7 +40,6 @@
 #include "llcheckboxctrl.h"
 #include "llcommandhandler.h"		// for secondlife:///app/login/
 #include "llcombobox.h"
-#include "llcurl.h"
 #include "llviewercontrol.h"
 #include "llfloaterpreference.h"
 #include "llfocusmgr.h"
diff --git a/indra/newview/lltexturefetch.h b/indra/newview/lltexturefetch.h
index e569175e8f..50233eee5e 100755
--- a/indra/newview/lltexturefetch.h
+++ b/indra/newview/lltexturefetch.h
@@ -37,7 +37,6 @@
 #include "lltextureinfo.h"
 #include "llapr.h"
 #include "llimageworker.h"
-#include "llcurl.h"
 #include "httprequest.h"
 #include "httpoptions.h"
 #include "httpheaders.h"
diff --git a/indra/newview/llxmlrpctransaction.cpp b/indra/newview/llxmlrpctransaction.cpp
index 5828aee7fc..442ed73c2d 100755
--- a/indra/newview/llxmlrpctransaction.cpp
+++ b/indra/newview/llxmlrpctransaction.cpp
@@ -34,8 +34,8 @@
 #include "llxmlrpctransaction.h"
 #include "llxmlrpclistener.h"
 
-#include "llcurl.h"
 #include "httpcommon.h"
+#include "llhttpconstants.h"
 #include "httprequest.h"
 #include "httpoptions.h"
 #include "httpheaders.h"
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index 03712c1065..57e2faca5b 100755
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -105,7 +105,6 @@
 #include "llspatialpartition.h"
 #include "llmutelist.h"
 #include "lltoolpie.h"
-#include "llcurl.h"
 #include "llnotifications.h"
 #include "llpathinglib.h"
 #include "llfloaterpathfindingconsole.h"
diff --git a/indra/newview/tests/llhttpretrypolicy_test.cpp b/indra/newview/tests/llhttpretrypolicy_test.cpp
index 8bd6cc2690..21c83184dc 100755
--- a/indra/newview/tests/llhttpretrypolicy_test.cpp
+++ b/indra/newview/tests/llhttpretrypolicy_test.cpp
@@ -234,13 +234,13 @@ void RetryPolicyTestObject::test<6>()
 
 	std::string str1("0");
 	seconds_to_wait = F32_MAX;
-	success = getSecondsUntilRetryAfter(str1, seconds_to_wait);
+    success = LLAdaptiveRetryPolicy::getSecondsUntilRetryAfter(str1, seconds_to_wait);
 	ensure("parse 1", success);
 	ensure_equals("parse 1", seconds_to_wait, 0.0);
 
 	std::string str2("999.9");
 	seconds_to_wait = F32_MAX;
-	success = getSecondsUntilRetryAfter(str2, seconds_to_wait);
+    success = LLAdaptiveRetryPolicy::getSecondsUntilRetryAfter(str2, seconds_to_wait);
 	ensure("parse 2", success);
 	ensure_approximately_equals("parse 2", seconds_to_wait, 999.9F, 8);
 
@@ -248,7 +248,7 @@ void RetryPolicyTestObject::test<6>()
 	time(&nowseconds);
 	std::string str3 = LLDate((F64)(nowseconds+44)).asRFC1123();
 	seconds_to_wait = F32_MAX;
-	success = getSecondsUntilRetryAfter(str3, seconds_to_wait);
+    success = LLAdaptiveRetryPolicy::getSecondsUntilRetryAfter(str3, seconds_to_wait);
 	std::cerr << " str3 [" << str3 << "]" << std::endl;
 	ensure("parse 3", success);
 	ensure_approximately_equals_range("parse 3", seconds_to_wait, 44.0F, 2.0F);
diff --git a/indra/test/message_tut.cpp b/indra/test/message_tut.cpp
index aa23699de0..8718360f0c 100755
--- a/indra/test/message_tut.cpp
+++ b/indra/test/message_tut.cpp
@@ -28,7 +28,7 @@
 #include <tut/tut.hpp>
 #include "linden_common.h"
 #include "lltut.h"
-
+#include "llhttpconstants.h"
 #include "llapr.h"
 #include "llmessageconfig.h"
 #include "llsdserialize.h"
diff --git a/indra/viewer_components/updater/llupdatedownloader.cpp b/indra/viewer_components/updater/llupdatedownloader.cpp
index f868e5cc2c..53c729469b 100755
--- a/indra/viewer_components/updater/llupdatedownloader.cpp
+++ b/indra/viewer_components/updater/llupdatedownloader.cpp
@@ -26,7 +26,7 @@
 #include "linden_common.h"
 
 #include "llupdatedownloader.h"
-
+#include "httpcommon.h"
 #include <stdexcept>
 #include <boost/format.hpp>
 #include <boost/lexical_cast.hpp>
@@ -39,7 +39,6 @@
 #include "llsdserialize.h"
 #include "llthread.h"
 #include "llupdaterservice.h"
-#include "llcurl.h"
 
 class LLUpdateDownloader::Implementation:
 	public LLThread
@@ -65,7 +64,7 @@ private:
 	curl_off_t mBandwidthLimit;
 	bool mCancelled;
 	LLUpdateDownloader::Client & mClient;
-	CURL * mCurl;
+	LLCore::LLHttp::CURL_ptr mCurl;
 	LLSD mDownloadData;
 	llofstream mDownloadStream;
 	unsigned char mDownloadPercent;
@@ -192,7 +191,7 @@ LLUpdateDownloader::Implementation::Implementation(LLUpdateDownloader::Client &
 	mBandwidthLimit(0),
 	mCancelled(false),
 	mClient(client),
-	mCurl(0),
+	mCurl(),
 	mDownloadPercent(0),
 	mHeaderList(0)
 {
@@ -212,10 +211,7 @@ LLUpdateDownloader::Implementation::~Implementation()
 	{
 		; // No op.
 	}
-	if(mCurl)
-	{
-		LLCurl::deleteEasyHandle(mCurl);
-	}
+    mCurl.reset();
 }
 
 
@@ -331,9 +327,9 @@ void LLUpdateDownloader::Implementation::setBandwidthLimit(U64 bytesPerSecond)
 {
 	if((mBandwidthLimit != bytesPerSecond) && isDownloading() && !mDownloadData["required"].asBoolean())
 	{
-		llassert(mCurl != 0);
+		llassert(static_cast<bool>(mCurl));
 		mBandwidthLimit = bytesPerSecond;
-		CURLcode code = curl_easy_setopt(mCurl, CURLOPT_MAX_RECV_SPEED_LARGE, &mBandwidthLimit);
+		CURLcode code = curl_easy_setopt(mCurl.get(), CURLOPT_MAX_RECV_SPEED_LARGE, &mBandwidthLimit);
 		if(code != CURLE_OK)
 		{
 			LL_WARNS("UpdaterService") << "unable to change dowload bandwidth" << LL_ENDL;
@@ -416,7 +412,7 @@ int LLUpdateDownloader::Implementation::onProgress(double downloadSize, double b
 
 void LLUpdateDownloader::Implementation::run(void)
 {
-	CURLcode code = curl_easy_perform(mCurl);
+    CURLcode code = curl_easy_perform(mCurl.get());
 	mDownloadStream.close();
 	if(code == CURLE_OK)
 	{
@@ -460,36 +456,36 @@ void LLUpdateDownloader::Implementation::run(void)
 
 void LLUpdateDownloader::Implementation::initializeCurlGet(std::string const & url, bool processHeader)
 {
-	if(mCurl == 0)
+	if(!mCurl)
 	{
-		mCurl = LLCurl::newEasyHandle();
+		mCurl = LLCore::LLHttp::createEasyHandle();
 	}
 	else
 	{
-		curl_easy_reset(mCurl);
+        curl_easy_reset(mCurl.get());
 	}
 
-	if(mCurl == 0)
+	if(!mCurl)
 	{
 		throw DownloadError("failed to initialize curl");
 	}
-	throwOnCurlError(curl_easy_setopt(mCurl, CURLOPT_NOSIGNAL, true));
-	throwOnCurlError(curl_easy_setopt(mCurl, CURLOPT_FOLLOWLOCATION, true));
-	throwOnCurlError(curl_easy_setopt(mCurl, CURLOPT_WRITEFUNCTION, &write_function));
-	throwOnCurlError(curl_easy_setopt(mCurl, CURLOPT_WRITEDATA, this));
+    throwOnCurlError(curl_easy_setopt(mCurl.get(), CURLOPT_NOSIGNAL, true));
+	throwOnCurlError(curl_easy_setopt(mCurl.get(), CURLOPT_FOLLOWLOCATION, true));
+	throwOnCurlError(curl_easy_setopt(mCurl.get(), CURLOPT_WRITEFUNCTION, &write_function));
+	throwOnCurlError(curl_easy_setopt(mCurl.get(), CURLOPT_WRITEDATA, this));
 	if(processHeader)
 	{
-	   throwOnCurlError(curl_easy_setopt(mCurl, CURLOPT_HEADERFUNCTION, &header_function));
-	   throwOnCurlError(curl_easy_setopt(mCurl, CURLOPT_HEADERDATA, this));
-	}
-	throwOnCurlError(curl_easy_setopt(mCurl, CURLOPT_HTTPGET, true));
-	throwOnCurlError(curl_easy_setopt(mCurl, CURLOPT_URL, url.c_str()));
-	throwOnCurlError(curl_easy_setopt(mCurl, CURLOPT_PROGRESSFUNCTION, &progress_callback));
-	throwOnCurlError(curl_easy_setopt(mCurl, CURLOPT_PROGRESSDATA, this));
-	throwOnCurlError(curl_easy_setopt(mCurl, CURLOPT_NOPROGRESS, false));
+	   throwOnCurlError(curl_easy_setopt(mCurl.get(), CURLOPT_HEADERFUNCTION, &header_function));
+	   throwOnCurlError(curl_easy_setopt(mCurl.get(), CURLOPT_HEADERDATA, this));
+	}
+	throwOnCurlError(curl_easy_setopt(mCurl.get(), CURLOPT_HTTPGET, true));
+	throwOnCurlError(curl_easy_setopt(mCurl.get(), CURLOPT_URL, url.c_str()));
+	throwOnCurlError(curl_easy_setopt(mCurl.get(), CURLOPT_PROGRESSFUNCTION, &progress_callback));
+	throwOnCurlError(curl_easy_setopt(mCurl.get(), CURLOPT_PROGRESSDATA, this));
+	throwOnCurlError(curl_easy_setopt(mCurl.get(), CURLOPT_NOPROGRESS, false));
 	// if it's a required update set the bandwidth limit to 0 (unlimited)
 	curl_off_t limit = mDownloadData["required"].asBoolean() ? 0 : mBandwidthLimit;
-	throwOnCurlError(curl_easy_setopt(mCurl, CURLOPT_MAX_RECV_SPEED_LARGE, limit));
+	throwOnCurlError(curl_easy_setopt(mCurl.get(), CURLOPT_MAX_RECV_SPEED_LARGE, limit));
 
 	mDownloadPercent = 0;
 }
@@ -511,7 +507,7 @@ void LLUpdateDownloader::Implementation::resumeDownloading(size_t startByte)
 	{
 		throw DownloadError("cannot add Range header");
 	}
-	throwOnCurlError(curl_easy_setopt(mCurl, CURLOPT_HTTPHEADER, mHeaderList));
+	throwOnCurlError(curl_easy_setopt(mCurl.get(), CURLOPT_HTTPHEADER, mHeaderList));
 
 	mDownloadStream.open(mDownloadData["path"].asString().c_str(),
 						 std::ios_base::out | std::ios_base::binary | std::ios_base::app);
-- 
cgit v1.3


From 2a37a8b1cc8796e4c86786017414f919dbaa6fac Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Mon, 21 Sep 2015 17:01:26 -0700
Subject: Add cleanup to LLCore prevent occasional crash on exit.

---
 indra/llcorehttp/httpcommon.cpp | 17 +++++++++++++++++
 indra/llcorehttp/httpcommon.h   |  1 +
 indra/newview/llappviewer.cpp   |  1 +
 3 files changed, 19 insertions(+)

(limited to 'indra/llcorehttp')

diff --git a/indra/llcorehttp/httpcommon.cpp b/indra/llcorehttp/httpcommon.cpp
index c606f2b754..c423047bb0 100755
--- a/indra/llcorehttp/httpcommon.cpp
+++ b/indra/llcorehttp/httpcommon.cpp
@@ -350,6 +350,11 @@ void deallocateEasyCurl(CURL *curlp)
 //static
 void ssl_locking_callback(int mode, int type, const char *file, int line)
 {
+    if (type >= sSSLMutex.size())
+    {
+        LL_WARNS() << "Attempt to get unknown MUTEX in SSL Lock." << LL_ENDL;
+    }
+
     if (mode & CRYPTO_LOCK)
     {
         sSSLMutex[type]->lock();
@@ -392,6 +397,18 @@ void initialize()
 }
 
 
+void cleanup()
+{
+#if SAFE_SSL
+    CRYPTO_set_id_callback(NULL);
+    CRYPTO_set_locking_callback(NULL);
+    sSSLMutex.clear();
+#endif
+
+    curl_global_cleanup();
+}
+
+
 CURL_ptr createEasyHandle()
 {
     LLMutexLock lock(getCurlMutex());
diff --git a/indra/llcorehttp/httpcommon.h b/indra/llcorehttp/httpcommon.h
index 3e98600a92..1bc20fe6b5 100755
--- a/indra/llcorehttp/httpcommon.h
+++ b/indra/llcorehttp/httpcommon.h
@@ -497,6 +497,7 @@ namespace LLHttp
     typedef boost::shared_ptr<CURL> CURL_ptr;
 
     void initialize();
+    void cleanup();
 
     CURL_ptr createEasyHandle();
     std::string getCURLVersion();
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 5cf9efa04e..44c9f893b8 100755
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -2077,6 +2077,7 @@ bool LLAppViewer::cleanup()
 	}
 	LL_INFOS() << "Cleaning up LLProxy." << LL_ENDL;
 	LLProxy::cleanupClass();
+    LLCore::LLHttp::cleanup();
 
 	LLWearableType::cleanupClass();
 
-- 
cgit v1.3


From 2d2c90157dbc75c4f1b4a8ac35ae67e005bc98b4 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 23 Sep 2015 15:48:06 -0700
Subject: Remove ares dependency from build.

---
 autobuild.xml                       | 54 -------------------------------------
 indra/cmake/00-COMPILE-LINK-RUN.txt |  2 --
 indra/cmake/CARes.cmake             | 21 ---------------
 indra/cmake/CMakeLists.txt          |  2 --
 indra/cmake/FindCARes.cmake         | 48 ---------------------------------
 indra/cmake/LLCoreHttp.cmake        |  2 --
 indra/cmake/LLMessage.cmake         |  2 --
 indra/llcorehttp/CMakeLists.txt     |  4 ---
 indra/llmessage/CMakeLists.txt      |  1 -
 9 files changed, 136 deletions(-)
 delete mode 100755 indra/cmake/CARes.cmake
 delete mode 100755 indra/cmake/FindCARes.cmake

(limited to 'indra/llcorehttp')

diff --git a/autobuild.xml b/autobuild.xml
index d772719034..7488b816ec 100755
--- a/autobuild.xml
+++ b/autobuild.xml
@@ -87,60 +87,6 @@
         <key>version</key>
         <string>1.4.5.297252</string>
       </map>
-      <key>ares</key>
-      <map>
-        <key>copyright</key>
-        <string>Copyright 1998 by the Massachusetts Institute of Technology.</string>
-        <key>description</key>
-        <string>C-ares, an asynchronous resolver library.</string>
-        <key>license</key>
-        <string>c-ares</string>
-        <key>license_file</key>
-        <string>LICENSES/c-ares.txt</string>
-        <key>name</key>
-        <string>ares</string>
-        <key>platforms</key>
-        <map>
-          <key>darwin</key>
-          <map>
-            <key>archive</key>
-            <map>
-              <key>hash</key>
-              <string>637b4996f703f3e5bf835d847fc4cb81</string>
-              <key>url</key>
-              <string>http://automated-builds-secondlife-com.s3.amazonaws.com/hg/repo/ares_3p-update-ares/rev/295506/arch/Darwin/installer/ares-1.10.0.295506-darwin-295506.tar.bz2</string>
-            </map>
-            <key>name</key>
-            <string>darwin</string>
-          </map>
-          <key>linux</key>
-          <map>
-            <key>archive</key>
-            <map>
-              <key>hash</key>
-              <string>7771d3653a0daf22d35bf96055d02d9a</string>
-              <key>url</key>
-              <string>http://automated-builds-secondlife-com.s3.amazonaws.com/hg/repo/ares_3p-update-ares/rev/295506/arch/Linux/installer/ares-1.10.0.295506-linux-295506.tar.bz2</string>
-            </map>
-            <key>name</key>
-            <string>linux</string>
-          </map>
-          <key>windows</key>
-          <map>
-            <key>archive</key>
-            <map>
-              <key>hash</key>
-              <string>f044de05e704d3f3fb6934adf42447c2</string>
-              <key>url</key>
-              <string>http://automated-builds-secondlife-com.s3.amazonaws.com/hg/repo/ares_3p-update-ares/rev/295506/arch/CYGWIN/installer/ares-1.10.0.295506-windows-295506.tar.bz2</string>
-            </map>
-            <key>name</key>
-            <string>windows</string>
-          </map>
-        </map>
-        <key>version</key>
-        <string>1.10.0.295506</string>
-      </map>
       <key>boost</key>
       <map>
         <key>copyright</key>
diff --git a/indra/cmake/00-COMPILE-LINK-RUN.txt b/indra/cmake/00-COMPILE-LINK-RUN.txt
index 49b899c50d..162b22865c 100644
--- a/indra/cmake/00-COMPILE-LINK-RUN.txt
+++ b/indra/cmake/00-COMPILE-LINK-RUN.txt
@@ -51,7 +51,6 @@ Compilation
                    WINVER=0x0501                 "                   "
                    _WIN32_WINNT=0x0501           "                   "
                    LL_OS_DRAGDROP_ENABLED=1      "                   "
-                   CARES_STATICLIB               "                   "
                    LIB_NDOF=1                    "                   "
 
     ----------------------------------------------------------------------------
@@ -109,7 +108,6 @@ Compilation
                                          DEBUG_INFO=1
                    LL_DARWIN=1                   "                   "
                    LL_OS_DRAGDROP_ENABLED=1      "                   "
-                   CARES_STATICLIB               "                   "
                    LIB_NDOF=1                    "                   "
 
     ----------------------------------------------------------------------------
diff --git a/indra/cmake/CARes.cmake b/indra/cmake/CARes.cmake
deleted file mode 100755
index baa55aa49d..0000000000
--- a/indra/cmake/CARes.cmake
+++ /dev/null
@@ -1,21 +0,0 @@
-# -*- cmake -*-
-include(Linking)
-include(Prebuilt)
-
-set(CARES_FIND_QUIETLY ON)
-set(CARES_FIND_REQUIRED ON)
-
-if (USESYSTEMLIBS)
-  include(FindCARes)
-else (USESYSTEMLIBS)
-    use_prebuilt_binary(ares)
-    add_definitions("-DCARES_STATICLIB")
-    if (WINDOWS)
-        set(CARES_LIBRARIES areslib)
-    elseif (DARWIN)
-       set(CARES_LIBRARIES cares)
-    else (WINDOWS)
-        set(CARES_LIBRARIES cares)
-    endif (WINDOWS)
-    set(CARES_INCLUDE_DIRS ${LIBS_PREBUILT_DIR}/include/ares)
-endif (USESYSTEMLIBS)
diff --git a/indra/cmake/CMakeLists.txt b/indra/cmake/CMakeLists.txt
index 40d7af8aab..d700c7fd99 100755
--- a/indra/cmake/CMakeLists.txt
+++ b/indra/cmake/CMakeLists.txt
@@ -13,7 +13,6 @@ set(cmake_SOURCE_FILES
     BerkeleyDB.cmake
     Boost.cmake
     BuildVersion.cmake
-    CARes.cmake
     CMakeCopyIfDifferent.cmake
     ConfigurePkgConfig.cmake
     CURL.cmake
@@ -27,7 +26,6 @@ set(cmake_SOURCE_FILES
     FindAPR.cmake
     FindAutobuild.cmake
     FindBerkeleyDB.cmake
-    FindCARes.cmake
     FindFMODEX.cmake
     FindGLH.cmake
     FindGoogleBreakpad.cmake
diff --git a/indra/cmake/FindCARes.cmake b/indra/cmake/FindCARes.cmake
deleted file mode 100755
index 1ed5b32913..0000000000
--- a/indra/cmake/FindCARes.cmake
+++ /dev/null
@@ -1,48 +0,0 @@
-# -*- cmake -*-
-
-# - Find c-ares
-# Find the c-ares includes and library
-# This module defines
-#  CARES_INCLUDE_DIR, where to find ares.h, etc.
-#  CARES_LIBRARIES, the libraries needed to use c-ares.
-#  CARES_FOUND, If false, do not try to use c-ares.
-# also defined, but not for general use are
-#  CARES_LIBRARY, where to find the c-ares library.
-
-FIND_PATH(CARES_INCLUDE_DIR ares.h
-/usr/local/include
-/usr/include
-)
-
-SET(CARES_NAMES ${CARES_NAMES} cares)
-FIND_LIBRARY(CARES_LIBRARY
-  NAMES ${CARES_NAMES}
-  PATHS /usr/lib /usr/local/lib
-  )
-
-IF (CARES_LIBRARY AND CARES_INCLUDE_DIR)
-    SET(CARES_LIBRARIES ${CARES_LIBRARY})
-    SET(CARES_FOUND "YES")
-ELSE (CARES_LIBRARY AND CARES_INCLUDE_DIR)
-  SET(CARES_FOUND "NO")
-ENDIF (CARES_LIBRARY AND CARES_INCLUDE_DIR)
-
-
-IF (CARES_FOUND)
-   IF (NOT CARES_FIND_QUIETLY)
-      MESSAGE(STATUS "Found c-ares: ${CARES_LIBRARIES}")
-   ENDIF (NOT CARES_FIND_QUIETLY)
-ELSE (CARES_FOUND)
-   IF (CARES_FIND_REQUIRED)
-      MESSAGE(FATAL_ERROR "Could not find c-ares library")
-   ENDIF (CARES_FIND_REQUIRED)
-ENDIF (CARES_FOUND)
-
-# Deprecated declarations.
-SET (NATIVE_CARES_INCLUDE_PATH ${CARES_INCLUDE_DIR} )
-GET_FILENAME_COMPONENT (NATIVE_CARES_LIB_PATH ${CARES_LIBRARY} PATH)
-
-MARK_AS_ADVANCED(
-  CARES_LIBRARY
-  CARES_INCLUDE_DIR
-  )
diff --git a/indra/cmake/LLCoreHttp.cmake b/indra/cmake/LLCoreHttp.cmake
index cc2e32e8b1..379ae207de 100755
--- a/indra/cmake/LLCoreHttp.cmake
+++ b/indra/cmake/LLCoreHttp.cmake
@@ -1,13 +1,11 @@
 # -*- cmake -*-
 
-include(CARes)
 include(CURL)
 include(OpenSSL)
 include(Boost)
 
 set(LLCOREHTTP_INCLUDE_DIRS
     ${LIBS_OPEN_DIR}/llcorehttp
-    ${CARES_INCLUDE_DIRS}
     ${CURL_INCLUDE_DIRS}
     ${OPENSSL_INCLUDE_DIRS}
     ${BOOST_INCLUDE_DIRS}
diff --git a/indra/cmake/LLMessage.cmake b/indra/cmake/LLMessage.cmake
index 0143d04fd7..7be53ec0ec 100755
--- a/indra/cmake/LLMessage.cmake
+++ b/indra/cmake/LLMessage.cmake
@@ -1,13 +1,11 @@
 # -*- cmake -*-
 
-include(CARes)
 include(CURL)
 include(OpenSSL)
 include(XmlRpcEpi)
 
 set(LLMESSAGE_INCLUDE_DIRS
     ${LIBS_OPEN_DIR}/llmessage
-    ${CARES_INCLUDE_DIRS}
     ${CURL_INCLUDE_DIRS}
     ${OPENSSL_INCLUDE_DIRS}
     )
diff --git a/indra/llcorehttp/CMakeLists.txt b/indra/llcorehttp/CMakeLists.txt
index 161823079b..4aecf61bd7 100755
--- a/indra/llcorehttp/CMakeLists.txt
+++ b/indra/llcorehttp/CMakeLists.txt
@@ -5,7 +5,6 @@ project(llcorehttp)
 include(00-Common)
 include(GoogleMock)
 include(CURL)
-include(CARes)
 include(OpenSSL)
 include(ZLIB)
 include(LLCoreHttp)
@@ -91,7 +90,6 @@ add_library (llcorehttp ${llcorehttp_SOURCE_FILES})
 target_link_libraries(
   llcorehttp
   ${CURL_LIBRARIES}
-  ${CARES_LIBRARIES}
   ${OPENSSL_LIBRARIES}
   ${CRYPTO_LIBRARIES}
   ${BOOST_THREAD_LIBRARY}
@@ -129,7 +127,6 @@ if (LL_TESTS)
       ${LLCOMMON_LIBRARIES}
       ${GOOGLEMOCK_LIBRARIES}
       ${CURL_LIBRARIES}
-      ${CARES_LIBRARIES}
       ${OPENSSL_LIBRARIES}
       ${CRYPTO_LIBRARIES}
       ${BOOST_SYSTEM_LIBRARY}
@@ -161,7 +158,6 @@ if (LL_TESTS)
       ${LLCOMMON_LIBRARIES}
       ${GOOGLEMOCK_LIBRARIES}
       ${CURL_LIBRARIES}
-      ${CARES_LIBRARIES}
       ${OPENSSL_LIBRARIES}
       ${CRYPTO_LIBRARIES}
       ${BOOST_SYSTEM_LIBRARY}
diff --git a/indra/llmessage/CMakeLists.txt b/indra/llmessage/CMakeLists.txt
index 5877c4a8e4..78c84f366a 100755
--- a/indra/llmessage/CMakeLists.txt
+++ b/indra/llmessage/CMakeLists.txt
@@ -209,7 +209,6 @@ target_link_libraries(
   ${LLCOMMON_LIBRARIES}
   ${LLVFS_LIBRARIES}
   ${LLMATH_LIBRARIES}
-  ${CARES_LIBRARIES}
   ${JSONCPP_LIBRARIES}
   ${OPENSSL_LIBRARIES}
   ${CRYPTO_LIBRARIES}
-- 
cgit v1.3