MAINT-5271: Converted internal pointers to internal operation to managed shared pointers. Removed direct cast and dereference of handles.

23 files changed, 307 insertions, 292 deletions

diff --git a/indra/llcorehttp/_httplibcurl.cpp b/indra/llcorehttp/_httplibcurl.cpp
index 17e997688f..4ebe14e740 100755
--- a/indra/llcorehttp/_httplibcurl.cpp
+++ b/indra/llcorehttp/_httplibcurl.cpp
@@ -71,11 +71,10 @@ void HttpLibcurl::shutdown()
 {
 	while (! mActiveOps.empty())
 	{
-		HttpOpRequest * op(* mActiveOps.begin());
+		HttpOpRequest::ptr_t op(* mActiveOps.begin());
 		mActiveOps.erase(mActiveOps.begin());
 
 		cancelRequest(op);
-		op->release();
 	}
 
 	if (mMultiHandles)
@@ -204,7 +203,7 @@ HttpService::ELoopSpeed HttpLibcurl::processTransport()
 
 
 // Caller has provided us with a ref count on op.
-void HttpLibcurl::addOp(HttpOpRequest * op)
+void HttpLibcurl::addOp(const HttpOpRequest::ptr_t &op)
 {
 	llassert_always(op->mReqPolicy < mPolicyCount);
 	llassert_always(mMultiHandles[op->mReqPolicy] != NULL);
@@ -235,21 +234,21 @@ void HttpLibcurl::addOp(HttpOpRequest * op)
 		HttpPolicy & policy(mService->getPolicy());
 		
 		LL_INFOS(LOG_CORE) << "TRACE, ToActiveQueue, Handle:  "
-						   << static_cast<HttpHandle>(op)
-						   << ", Actives:  " << mActiveOps.size()
-						   << ", Readies:  " << policy.getReadyCount(op->mReqPolicy)
-						   << LL_ENDL;
+                            << op->getHandle()
+						    << ", Actives:  " << mActiveOps.size()
+						    << ", Readies:  " << policy.getReadyCount(op->mReqPolicy)
+						    << LL_ENDL;
 	}
 }
 
 
 // Implements the transport part of any cancel operation.
 // See if the handle is an active operation and if so,
-// use the more complicated transport-based cancelation
+// use the more complicated transport-based cancellation
 // method to kill the request.
 bool HttpLibcurl::cancel(HttpHandle handle)
 {
-	HttpOpRequest * op(static_cast<HttpOpRequest *>(handle));
+    HttpOpRequest::ptr_t op = HttpOpRequest::fromHandle<HttpOpRequest>(handle);
 	active_set_t::iterator it(mActiveOps.find(op));
 	if (mActiveOps.end() == it)
 	{
@@ -262,7 +261,6 @@ bool HttpLibcurl::cancel(HttpHandle handle)
 	// Drop references
 	mActiveOps.erase(it);
 	--mActiveHandles[op->mReqPolicy];
-	op->release();
 
 	return true;
 }
@@ -273,7 +271,7 @@ bool HttpLibcurl::cancel(HttpHandle handle)
 // remove the op from the active list and release the op *after*
 // calling this method.  It must be called first to deliver the
 // op to the reply queue with refcount intact.
-void HttpLibcurl::cancelRequest(HttpOpRequest * op)
+void HttpLibcurl::cancelRequest(const HttpOpRequest::ptr_t &op)
 {
 	// Deactivate request
 	op->mCurlActive = false;
@@ -287,7 +285,7 @@ void HttpLibcurl::cancelRequest(HttpOpRequest * op)
 	if (op->mTracing > HTTP_TRACE_OFF)
 	{
 		LL_INFOS(LOG_CORE) << "TRACE, RequestCanceled, Handle:  "
-						   << static_cast<HttpHandle>(op)
+						   << op->getHandle()
 						   << ", Status:  " << op->mStatus.toTerseString()
 						   << LL_ENDL;
 	}
@@ -301,8 +299,11 @@ void HttpLibcurl::cancelRequest(HttpOpRequest * op)
 // Keep them synchronized as necessary.
 bool HttpLibcurl::completeRequest(CURLM * multi_handle, CURL * handle, CURLcode status)
 {
-	HttpOpRequest * op(NULL);
-	curl_easy_getinfo(handle, CURLINFO_PRIVATE, &op);
+    HttpHandle ophandle(NULL);
+
+	curl_easy_getinfo(handle, CURLINFO_PRIVATE, &ophandle);
+    HttpOpRequest::ptr_t op(HttpOpRequest::fromHandle<HttpOpRequest>(ophandle));
+    
 
 	if (handle != op->mCurlHandle || ! op->mCurlActive)
 	{
@@ -364,9 +365,9 @@ bool HttpLibcurl::completeRequest(CURLM * multi_handle, CURL * handle, CURLcode
 	if (op->mTracing > HTTP_TRACE_OFF)
 	{
 		LL_INFOS(LOG_CORE) << "TRACE, RequestComplete, Handle:  "
-						   << static_cast<HttpHandle>(op)
-						   << ", Status:  " << op->mStatus.toTerseString()
-						   << LL_ENDL;
+                            << op->getHandle()
+						    << ", Status:  " << op->mStatus.toTerseString()
+						    << LL_ENDL;
 	}
 
 	// Dispatch to next stage
diff --git a/indra/llcorehttp/_httplibcurl.h b/indra/llcorehttp/_httplibcurl.h
index ffc24c63a8..a71eae59c0 100755
--- a/indra/llcorehttp/_httplibcurl.h
+++ b/indra/llcorehttp/_httplibcurl.h
@@ -65,6 +65,8 @@ private:
 	void operator=(const HttpLibcurl &);		// Not defined
 
 public:
+    typedef boost::shared_ptr<HttpOpRequest> opReqPtr_t;
+
 	/// Give cycles to libcurl to run active requests.  Completed
 	/// operations (successful or failed) will be retried or handed
 	/// over to the reply queue as final responses.
@@ -80,7 +82,7 @@ public:
 	/// request.  (No additional references will be added.)
 	///
 	/// Threading:  called by worker thread.
-	void addOp(HttpOpRequest * op);
+    void addOp(const opReqPtr_t & op);
 
 	/// One-time call to set the number of policy classes to be
 	/// serviced and to create the resources for each.  Value
@@ -148,10 +150,10 @@ protected:
 
 	/// Invoked to cancel an active request, mainly during shutdown
 	/// and destroy.
-	void cancelRequest(HttpOpRequest * op);
+    void cancelRequest(const opReqPtr_t &op);
 	
 protected:
-	typedef std::set<HttpOpRequest *> active_set_t;
+    typedef std::set<opReqPtr_t> active_set_t;
 
 	/// Simple request handle cache for libcurl.
 	///
diff --git a/indra/llcorehttp/_httpopcancel.h b/indra/llcorehttp/_httpopcancel.h
index 336dfdc573..86944eb159 100755
--- a/indra/llcorehttp/_httpopcancel.h
+++ b/indra/llcorehttp/_httpopcancel.h
@@ -56,13 +56,8 @@ public:
 	///					be canceled.
 	HttpOpCancel(HttpHandle handle);
 
-protected:
 	virtual ~HttpOpCancel();							// Use release()
 	
-private:
-	HttpOpCancel(const HttpOpCancel &);					// Not defined
-	void operator=(const HttpOpCancel &);				// Not defined
-
 public:
 	virtual void stageFromRequest(HttpService *);
 			
diff --git a/indra/llcorehttp/_httpoperation.cpp b/indra/llcorehttp/_httpoperation.cpp
index dc03b059a4..333f20d281 100755
--- a/indra/llcorehttp/_httpoperation.cpp
+++ b/indra/llcorehttp/_httpoperation.cpp
@@ -53,15 +53,18 @@ namespace LLCore
 // ==================================
 // HttpOperation
 // ==================================
-
-
-HttpOperation::HttpOperation()
-	: LLCoreInt::RefCounted(true),
-	  mReplyQueue(),
-	  mUserHandler(),
-	  mReqPolicy(HttpRequest::DEFAULT_POLICY_ID),
-	  mReqPriority(0U),
-	  mTracing(HTTP_TRACE_OFF)
+/*static*/ 
+HttpOperation::handleMap_t  HttpOperation::mHandleMap;
+LLCoreInt::HttpMutex	    HttpOperation::mOpMutex;
+
+HttpOperation::HttpOperation():
+    boost::enable_shared_from_this<HttpOperation>(),
+    mReplyQueue(),
+    mUserHandler(),
+    mReqPolicy(HttpRequest::DEFAULT_POLICY_ID),
+    mReqPriority(0U),
+    mTracing(HTTP_TRACE_OFF),
+    mMyHandle(LLCORE_HTTP_HANDLE_INVALID)
 {
 	mMetricCreated = totalTime();
 }
@@ -69,7 +72,9 @@ HttpOperation::HttpOperation()
 
 HttpOperation::~HttpOperation()
 {
-    setReplyPath(HttpReplyQueue::ptr_t(), HttpHandler::ptr_t());
+    destroyHandle();
+    mReplyQueue.reset();
+    mUserHandler.reset();
 }
 
 
@@ -119,7 +124,7 @@ void HttpOperation::visitNotifier(HttpRequest *)
 		HttpResponse * response = new HttpResponse();
 
 		response->setStatus(mStatus);
-		mUserHandler->onCompleted(static_cast<HttpHandle>(this), response);
+		mUserHandler->onCompleted(getHandle(), response);
 
 		response->release();
 	}
@@ -133,20 +138,80 @@ HttpStatus HttpOperation::cancel()
 	return status;
 }
 
+// Handle methods
+HttpHandle HttpOperation::getHandle()
+{
+    if (mMyHandle == LLCORE_HTTP_HANDLE_INVALID)
+        return createHandle();
+
+    return mMyHandle;
+}
+
+HttpHandle HttpOperation::createHandle()
+{
+    HttpHandle handle = static_cast<HttpHandle>(this);
+
+    {
+        LLCoreInt::HttpScopedLock lock(mOpMutex);
+
+        mHandleMap[handle] = shared_from_this();
+        mMyHandle = handle;
+    }
+
+    return mMyHandle;
+}
+
+void HttpOperation::destroyHandle()
+{
+    if (mMyHandle == LLCORE_HTTP_HANDLE_INVALID)
+        return;
+    {
+        LLCoreInt::HttpScopedLock lock(mOpMutex);
+
+        handleMap_t::iterator it = mHandleMap.find(mMyHandle);
+        if (it != mHandleMap.end())
+            mHandleMap.erase(it);
+    }
+}
+
+/*static*/
+HttpOperation::ptr_t HttpOperation::findByHandle(HttpHandle handle)
+{
+    wptr_t weak;
+
+    {
+        LLCoreInt::HttpScopedLock lock(mOpMutex);
+
+        handleMap_t::iterator it = mHandleMap.find(handle);
+        if (it == mHandleMap.end())
+        {
+            LL_WARNS("LLCore::HTTP") << "Could not find operation for handle " << handle << LL_ENDL;
+            return ptr_t();
+        }
+
+        weak = (*it).second;
+    }
+
+    if (!weak.expired())
+        return weak.lock();
+    
+    return ptr_t();
+}
+
 
 void HttpOperation::addAsReply()
 {
 	if (mTracing > HTTP_TRACE_OFF)
 	{
 		LL_INFOS(LOG_CORE) << "TRACE, ToReplyQueue, Handle:  "
-						   << static_cast<HttpHandle>(this)
+						   << getHandle()
 						   << LL_ENDL;
 	}
 	
 	if (mReplyQueue)
 	{
-		addRef();
-		mReplyQueue->addOp(this);
+        HttpOperation::ptr_t op = shared_from_this();
+		mReplyQueue->addOp(op);
 	}
 }
 
@@ -229,11 +294,8 @@ void HttpOpSpin::stageFromRequest(HttpService * service)
 	else
 	{
 		ms_sleep(1);			// backoff interlock plumbing a bit
-		this->addRef();
-		if (! service->getRequestQueue().addOp(this))
-		{
-			this->release();
-		}
+        HttpOperation::ptr_t opptr = shared_from_this();
+        service->getRequestQueue().addOp(opptr);
 	}
 }
 
diff --git a/indra/llcorehttp/_httpoperation.h b/indra/llcorehttp/_httpoperation.h
index f677e7aed8..417bdc7c50 100755
--- a/indra/llcorehttp/_httpoperation.h
+++ b/indra/llcorehttp/_httpoperation.h
@@ -30,8 +30,7 @@
 
 #include "httpcommon.h"
 #include "httprequest.h"
-#include "_refcounted.h"
-
+#include "_mutex.h"
 
 namespace LLCore
 {
@@ -69,21 +68,20 @@ class HttpService;
 /// via queue-like interfaces that are thread compatible
 /// and those interfaces establish the access rules.
 
-class HttpOperation : public LLCoreInt::RefCounted
+class HttpOperation : private boost::noncopyable,
+    public boost::enable_shared_from_this<HttpOperation>
 {
 public:
+    typedef boost::shared_ptr<HttpOperation> ptr_t;
+    typedef boost::weak_ptr<HttpOperation> wptr_t;
     typedef boost::shared_ptr<HttpReplyQueue> HttpReplyQueuePtr_t;
 
 	/// Threading:  called by consumer thread.
 	HttpOperation();
 
-protected:
 	/// Threading:  called by any thread.
 	virtual ~HttpOperation();							// Use release()
 
-private:
-	HttpOperation(const HttpOperation &);				// Not defined
-	void operator=(const HttpOperation &);				// Not defined
 
 public:
 	/// Register a reply queue and a handler for completion notifications.
@@ -154,6 +152,18 @@ public:
 	/// Threading:  called by worker thread.
 	///
 	virtual HttpStatus cancel();
+
+    /// Retrieves a unique handle for this operation.
+    HttpHandle getHandle();
+
+    template< class OPT >
+    static boost::shared_ptr< OPT > fromHandle(HttpHandle handle)
+    {
+        ptr_t ptr = findByHandle(handle);
+        if (!ptr)
+            return boost::shared_ptr< OPT >();
+        return boost::dynamic_pointer_cast<HttpOpRequest>(ptr);
+    }
 	
 protected:
 	/// Delivers request to reply queue on completion.  After this
@@ -179,6 +189,21 @@ public:
 	// Tracing, debug and metrics
 	HttpTime					mMetricCreated;
 	int							mTracing;
+
+private:
+    typedef std::map<HttpHandle, wptr_t>    handleMap_t;
+
+    HttpHandle                  createHandle();
+    void                        destroyHandle();
+    HttpHandle                  mMyHandle;
+
+    static handleMap_t          mHandleMap;
+    static LLCoreInt::HttpMutex	mOpMutex;
+
+protected:
+    static ptr_t                findByHandle(HttpHandle handle);
+
+
 };  // end class HttpOperation
 
 
@@ -197,7 +222,6 @@ class HttpOpStop : public HttpOperation
 public:
 	HttpOpStop();
 
-protected:
 	virtual ~HttpOpStop();
 
 private:
@@ -220,7 +244,6 @@ class HttpOpNull : public HttpOperation
 public:
 	HttpOpNull();
 
-protected:
 	virtual ~HttpOpNull();
 
 private:
@@ -243,7 +266,6 @@ public:
 	// 1 does a soft spin continuously requeuing itself
 	HttpOpSpin(int mode);
 
-protected:
 	virtual ~HttpOpSpin();
 
 private:
diff --git a/indra/llcorehttp/_httpoprequest.cpp b/indra/llcorehttp/_httpoprequest.cpp
index 86110f5b46..557f6207b5 100755
--- a/indra/llcorehttp/_httpoprequest.cpp
+++ b/indra/llcorehttp/_httpoprequest.cpp
@@ -187,15 +187,15 @@ HttpOpRequest::~HttpOpRequest()
 
 void HttpOpRequest::stageFromRequest(HttpService * service)
 {
-	addRef();
-	service->getPolicy().addOp(this);			// transfers refcount
+    HttpOpRequest::ptr_t self(boost::dynamic_pointer_cast<HttpOpRequest>(shared_from_this()));
+    service->getPolicy().addOp(self);			// transfers refcount
 }
 
 
 void HttpOpRequest::stageFromReady(HttpService * service)
 {
-	addRef();
-	service->getTransport().addOp(this);		// transfers refcount
+    HttpOpRequest::ptr_t self(boost::dynamic_pointer_cast<HttpOpRequest>(shared_from_this()));
+    service->getTransport().addOp(self);		// transfers refcount
 }
 
 
@@ -261,12 +261,19 @@ void HttpOpRequest::visitNotifier(HttpRequest * request)
 
 		response->setTransferStats(stats);
 
-		mUserHandler->onCompleted(static_cast<HttpHandle>(this), response);
+		mUserHandler->onCompleted(this->getHandle(), response);
 
 		response->release();
 	}
 }
 
+// /*static*/
+// HttpOpRequest::ptr_t HttpOpRequest::fromHandle(HttpHandle handle)
+// {
+// 
+//     return boost::dynamic_pointer_cast<HttpOpRequest>((static_cast<HttpOpRequest *>(handle))->shared_from_this());
+// }
+
 
 HttpStatus HttpOpRequest::cancel()
 {
@@ -488,7 +495,7 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 	check_curl_easy_code(code, CURLOPT_NOPROGRESS);
 	code = curl_easy_setopt(mCurlHandle, CURLOPT_URL, mReqURL.c_str());
 	check_curl_easy_code(code, CURLOPT_URL);
-	code = curl_easy_setopt(mCurlHandle, CURLOPT_PRIVATE, this);
+	code = curl_easy_setopt(mCurlHandle, CURLOPT_PRIVATE, getHandle());
 	check_curl_easy_code(code, CURLOPT_PRIVATE);
 	code = curl_easy_setopt(mCurlHandle, CURLOPT_ENCODING, "");
 	check_curl_easy_code(code, CURLOPT_ENCODING);
@@ -499,15 +506,15 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 	check_curl_easy_code(code, CURLOPT_MAXREDIRS);
 	code = curl_easy_setopt(mCurlHandle, CURLOPT_WRITEFUNCTION, writeCallback);
 	check_curl_easy_code(code, CURLOPT_WRITEFUNCTION);
-	code = curl_easy_setopt(mCurlHandle, CURLOPT_WRITEDATA, this);
+    code = curl_easy_setopt(mCurlHandle, CURLOPT_WRITEDATA, getHandle());
 	check_curl_easy_code(code, CURLOPT_WRITEDATA);
 	code = curl_easy_setopt(mCurlHandle, CURLOPT_READFUNCTION, readCallback);
 	check_curl_easy_code(code, CURLOPT_READFUNCTION);
-	code = curl_easy_setopt(mCurlHandle, CURLOPT_READDATA, this);
+    code = curl_easy_setopt(mCurlHandle, CURLOPT_READDATA, getHandle());
 	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);
+    code = curl_easy_setopt(mCurlHandle, CURLOPT_SEEKDATA, getHandle());
     check_curl_easy_code(code, CURLOPT_SEEKDATA);
 
 	code = curl_easy_setopt(mCurlHandle, CURLOPT_COOKIEFILE, "");
@@ -517,7 +524,7 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 	{
 		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);
+        code = curl_easy_setopt(mCurlHandle, CURLOPT_SSL_CTX_DATA, getHandle());
 		check_curl_easy_code(code, CURLOPT_SSL_CTX_DATA);
 		mCallbackSSLVerify = gpolicy.mSslCtxCallback;
 	}
@@ -776,7 +783,7 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 
 size_t HttpOpRequest::writeCallback(void * data, size_t size, size_t nmemb, void * userdata)
 {
-	HttpOpRequest * op(static_cast<HttpOpRequest *>(userdata));
+    HttpOpRequest::ptr_t op(HttpOpRequest::fromHandle<HttpOpRequest>(userdata));
 
 	if (! op->mReplyBody)
 	{
@@ -790,7 +797,7 @@ size_t HttpOpRequest::writeCallback(void * data, size_t size, size_t nmemb, void
 		
 size_t HttpOpRequest::readCallback(void * data, size_t size, size_t nmemb, void * userdata)
 {
-	HttpOpRequest * op(static_cast<HttpOpRequest *>(userdata));
+    HttpOpRequest::ptr_t op(HttpOpRequest::fromHandle<HttpOpRequest>(userdata));
 
 	if (! op->mReqBody)
 	{
@@ -819,7 +826,7 @@ size_t HttpOpRequest::readCallback(void * data, size_t size, size_t nmemb, void
 
 int HttpOpRequest::seekCallback(void *userdata, curl_off_t offset, int origin)
 {
-    HttpOpRequest * op(static_cast<HttpOpRequest *>(userdata));
+    HttpOpRequest::ptr_t op(HttpOpRequest::fromHandle<HttpOpRequest>(userdata));
 
     if (!op->mReqBody)
     {
@@ -855,7 +862,7 @@ size_t HttpOpRequest::headerCallback(void * data, size_t size, size_t nmemb, voi
 	static const char con_ran_line[] = "content-range";
 	static const char con_retry_line[] = "retry-after";
 	
-	HttpOpRequest * op(static_cast<HttpOpRequest *>(userdata));
+    HttpOpRequest::ptr_t op(HttpOpRequest::fromHandle<HttpOpRequest>(userdata));
 
 	const size_t hdr_size(size * nmemb);
 	const char * hdr_data(static_cast<const char *>(data));		// Not null terminated
@@ -999,7 +1006,7 @@ 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));
+    HttpOpRequest::ptr_t op(HttpOpRequest::fromHandle<HttpOpRequest>(userdata));
 
 	if (op->mCallbackSSLVerify)
 	{
@@ -1016,7 +1023,7 @@ CURLcode HttpOpRequest::curlSslCtxCallback(CURL *curl, void *sslctx, void *userd
 
 int HttpOpRequest::sslCertVerifyCallback(X509_STORE_CTX *ctx, void *param)
 {
-	HttpOpRequest * op(static_cast<HttpOpRequest *>(param));
+    HttpOpRequest::ptr_t op(HttpOpRequest::fromHandle<HttpOpRequest>(param));
 
 	if (op->mCallbackSSLVerify)
 	{
@@ -1028,7 +1035,7 @@ int HttpOpRequest::sslCertVerifyCallback(X509_STORE_CTX *ctx, void *param)
 
 int HttpOpRequest::debugCallback(CURL * handle, curl_infotype info, char * buffer, size_t len, void * userdata)
 {
-	HttpOpRequest * op(static_cast<HttpOpRequest *>(userdata));
+    HttpOpRequest::ptr_t op(HttpOpRequest::fromHandle<HttpOpRequest>(userdata));
 
 	std::string safe_line;
 	std::string tag;
@@ -1108,7 +1115,7 @@ int HttpOpRequest::debugCallback(CURL * handle, curl_infotype info, char * buffe
 	if (logit)
 	{
 		LL_INFOS(LOG_CORE) << "TRACE, LibcurlDebug, Handle:  "
-						   << static_cast<HttpHandle>(op)
+						   << op->getHandle()
 						   << ", Type:  " << tag
 						   << ", Data:  " << safe_line
 						   << LL_ENDL;
diff --git a/indra/llcorehttp/_httpoprequest.h b/indra/llcorehttp/_httpoprequest.h
index 1b449a5abc..dbcc57d0fd 100755
--- a/indra/llcorehttp/_httpoprequest.h
+++ b/indra/llcorehttp/_httpoprequest.h
@@ -66,9 +66,10 @@ class BufferArray;
 class HttpOpRequest : public HttpOperation
 {
 public:
+    typedef boost::shared_ptr<HttpOpRequest> ptr_t;
+
 	HttpOpRequest();
 
-protected:
 	virtual ~HttpOpRequest();							// Use release()
 
 private:
diff --git a/indra/llcorehttp/_httpopsetget.h b/indra/llcorehttp/_httpopsetget.h
index a1e76dd429..eabd41e79f 100755
--- a/indra/llcorehttp/_httpopsetget.h
+++ b/indra/llcorehttp/_httpopsetget.h
@@ -53,9 +53,10 @@ namespace LLCore
 class HttpOpSetGet : public HttpOperation
 {
 public:
+    typedef boost::shared_ptr<HttpOpSetGet> ptr_t;
+
 	HttpOpSetGet();
 
-protected:
 	virtual ~HttpOpSetGet();							// Use release()
 
 private:
diff --git a/indra/llcorehttp/_httpopsetpriority.h b/indra/llcorehttp/_httpopsetpriority.h
index 31706b737c..43e2aa081b 100755
--- a/indra/llcorehttp/_httpopsetpriority.h
+++ b/indra/llcorehttp/_httpopsetpriority.h
@@ -51,7 +51,6 @@ class HttpOpSetPriority : public HttpOperation
 public:
 	HttpOpSetPriority(HttpHandle handle, HttpRequest::priority_t priority);
 
-protected:
 	virtual ~HttpOpSetPriority();
 
 private:
diff --git a/indra/llcorehttp/_httppolicy.cpp b/indra/llcorehttp/_httppolicy.cpp
index e5d6321401..fd78a5dadc 100755
--- a/indra/llcorehttp/_httppolicy.cpp
+++ b/indra/llcorehttp/_httppolicy.cpp
@@ -116,21 +116,19 @@ void HttpPolicy::shutdown()
 		HttpRetryQueue & retryq(state.mRetryQueue);
 		while (! retryq.empty())
 		{
-			HttpOpRequest * op(retryq.top());
+			HttpOpRequest::ptr_t op(retryq.top());
 			retryq.pop();
 		
 			op->cancel();
-			op->release();
 		}
 
 		HttpReadyQueue & readyq(state.mReadyQueue);
 		while (! readyq.empty())
 		{
-			HttpOpRequest * op(readyq.top());
+			HttpOpRequest::ptr_t op(readyq.top());
 			readyq.pop();
 		
 			op->cancel();
-			op->release();
 		}
 	}
 }
@@ -141,7 +139,7 @@ void HttpPolicy::start()
 }
 
 
-void HttpPolicy::addOp(HttpOpRequest * op)
+void HttpPolicy::addOp(const HttpOpRequest::ptr_t &op)
 {
 	const int policy_class(op->mReqPolicy);
 	
@@ -151,7 +149,7 @@ void HttpPolicy::addOp(HttpOpRequest * op)
 }
 
 
-void HttpPolicy::retryOp(HttpOpRequest * op)
+void HttpPolicy::retryOp(const HttpOpRequest::ptr_t &op)
 {
 	static const HttpTime retry_deltas[] =
 		{
@@ -180,7 +178,7 @@ void HttpPolicy::retryOp(HttpOpRequest * op)
 	{
 		++op->mPolicy503Retries;
 	}
-	LL_DEBUGS(LOG_CORE) << "HTTP request " << static_cast<HttpHandle>(op)
+	LL_DEBUGS(LOG_CORE) << "HTTP request " << op->getHandle()
 						<< " retry " << op->mPolicyRetries
 						<< " scheduled in " << (delta / HttpTime(1000))
 						<< " mS (" << (external_delta ? "external" : "internal")
@@ -189,10 +187,10 @@ void HttpPolicy::retryOp(HttpOpRequest * op)
 	if (op->mTracing > HTTP_TRACE_OFF)
 	{
 		LL_INFOS(LOG_CORE) << "TRACE, ToRetryQueue, Handle:  "
-						   << static_cast<HttpHandle>(op)
-						   << ", Delta:  " << (delta / HttpTime(1000))
-						   << ", Retries:  " << op->mPolicyRetries
-						   << LL_ENDL;
+                            << op->getHandle()
+						    << ", Delta:  " << (delta / HttpTime(1000))
+						    << ", Retries:  " << op->mPolicyRetries
+						    << LL_ENDL;
 	}
 	mClasses[policy_class]->mRetryQueue.push(op);
 }
@@ -264,14 +262,14 @@ HttpService::ELoopSpeed HttpPolicy::processReadyQueue()
 			// First see if we have any retries...
 			while (needed > 0 && ! retryq.empty())
 			{
-				HttpOpRequest * op(retryq.top());
+				HttpOpRequest::ptr_t op(retryq.top());
 				if (op->mPolicyRetryAt > now)
 					break;
 			
 				retryq.pop();
 				
 				op->stageFromReady(mService);
-				op->release();
+                op.reset();
 
 				++state.mRequestCount;
 				--needed;
@@ -296,11 +294,11 @@ HttpService::ELoopSpeed HttpPolicy::processReadyQueue()
 			// Now go on to the new requests...
 			while (needed > 0 && ! readyq.empty())
 			{
-				HttpOpRequest * op(readyq.top());
+				HttpOpRequest::ptr_t op(readyq.top());
 				readyq.pop();
 
 				op->stageFromReady(mService);
-				op->release();
+				op.reset();
 					
 				++state.mRequestCount;
 				--needed;
@@ -351,9 +349,9 @@ bool HttpPolicy::changePriority(HttpHandle handle, HttpRequest::priority_t prior
 		{
 			HttpReadyQueue::container_type::iterator cur(iter++);
 
-			if (static_cast<HttpHandle>(*cur) == handle)
+			if ((*cur)->getHandle() == handle)
 			{
-				HttpOpRequest * op(*cur);
+				HttpOpRequest::ptr_t op(*cur);
 				c.erase(cur);									// All iterators are now invalidated
 				op->mReqPriority = priority;
 				state.mReadyQueue.push(op);						// Re-insert using adapter class
@@ -378,12 +376,11 @@ bool HttpPolicy::cancel(HttpHandle handle)
 		{
 			HttpRetryQueue::container_type::iterator cur(iter++);
 
-			if (static_cast<HttpHandle>(*cur) == handle)
+			if ((*cur)->getHandle() == handle)
 			{
-				HttpOpRequest * op(*cur);
+				HttpOpRequest::ptr_t op(*cur);
 				c1.erase(cur);									// All iterators are now invalidated
 				op->cancel();
-				op->release();
 				return true;
 			}
 		}
@@ -394,12 +391,11 @@ bool HttpPolicy::cancel(HttpHandle handle)
 		{
 			HttpReadyQueue::container_type::iterator cur(iter++);
 
-			if (static_cast<HttpHandle>(*cur) == handle)
+			if ((*cur)->getHandle() == handle)
 			{
-				HttpOpRequest * op(*cur);
+				HttpOpRequest::ptr_t op(*cur);
 				c2.erase(cur);									// All iterators are now invalidated
 				op->cancel();
-				op->release();
 				return true;
 			}
 		}
@@ -409,7 +405,7 @@ bool HttpPolicy::cancel(HttpHandle handle)
 }
 
 
-bool HttpPolicy::stageAfterCompletion(HttpOpRequest * op)
+bool HttpPolicy::stageAfterCompletion(const HttpOpRequest::ptr_t &op)
 {
 	// Retry or finalize
 	if (! op->mStatus)
@@ -438,7 +434,7 @@ bool HttpPolicy::stageAfterCompletion(HttpOpRequest * op)
 	// This op is done, finalize it delivering it to the reply queue...
 	if (! op->mStatus)
 	{
-		LL_WARNS(LOG_CORE) << "HTTP request " << static_cast<HttpHandle>(op)
+		LL_WARNS(LOG_CORE) << "HTTP request " << op->getHandle()
 						   << " failed after " << op->mPolicyRetries
 						   << " retries.  Reason:  " << op->mStatus.toString()
 						   << " (" << op->mStatus.toTerseString() << ")"
@@ -446,13 +442,12 @@ bool HttpPolicy::stageAfterCompletion(HttpOpRequest * op)
 	}
 	else if (op->mPolicyRetries)
 	{
-		LL_DEBUGS(LOG_CORE) << "HTTP request " << static_cast<HttpHandle>(op)
+        LL_DEBUGS(LOG_CORE) << "HTTP request " << op->getHandle()
 							<< " succeeded on retry " << op->mPolicyRetries << "."
 							<< LL_ENDL;
 	}
 
 	op->stageFromActive(mService);
-	op->release();
 	return false;						// not active
 }
 
diff --git a/indra/llcorehttp/_httppolicy.h b/indra/llcorehttp/_httppolicy.h
index 11cd89bbd1..3c4126e14b 100755
--- a/indra/llcorehttp/_httppolicy.h
+++ b/indra/llcorehttp/_httppolicy.h
@@ -60,6 +60,8 @@ private:
 	void operator=(const HttpPolicy &);			// Not defined
 
 public:
+    typedef boost::shared_ptr<HttpOpRequest> opReqPtr_t;
+
 	/// Threading:  called by init thread.
 	HttpRequest::policy_t createPolicyClass();
 	
@@ -96,7 +98,7 @@ public:
 	/// from queue.
 	///
 	/// Threading:  called by worker thread
-	void addOp(HttpOpRequest *);
+    void addOp(const opReqPtr_t &);
 
 	/// Similar to addOp, used when a caller wants to retry a
 	/// request that has failed.  It's placed on a special retry
@@ -106,7 +108,7 @@ public:
 	/// order.
 	///
 	/// Threading:  called by worker thread
-	void retryOp(HttpOpRequest *);
+    void retryOp(const opReqPtr_t &);
 
 	/// Attempt to change the priority of an earlier request.
 	/// Request that Shadows HttpService's method
@@ -130,7 +132,7 @@ public:
 	///					sent on to the reply queue.
 	///
 	/// Threading:  called by worker thread
-	bool stageAfterCompletion(HttpOpRequest * op);
+    bool stageAfterCompletion(const opReqPtr_t &op);
 	
 	/// Get a reference to global policy options.  Caller is expected
 	/// to do context checks like no setting once running.  These
diff --git a/indra/llcorehttp/_httpreadyqueue.h b/indra/llcorehttp/_httpreadyqueue.h
index 5f19a9c5f9..7418988ec1 100755
--- a/indra/llcorehttp/_httpreadyqueue.h
+++ b/indra/llcorehttp/_httpreadyqueue.h
@@ -56,12 +56,12 @@ namespace LLCore
 
 #if LLCORE_HTTP_READY_QUEUE_IGNORES_PRIORITY
 
-typedef std::deque<HttpOpRequest *> HttpReadyQueueBase;
+typedef std::deque<HttpOpRequest::ptr_t> HttpReadyQueueBase;
 
 #else
 
-typedef std::priority_queue<HttpOpRequest *,
-							std::deque<HttpOpRequest *>,
+typedef std::priority_queue<HttpOpRequest::ptr_t,
+							std::deque<HttpOpRequest::ptr_t>,
 							LLCore::HttpOpRequestCompare> HttpReadyQueueBase;
 
 #endif // LLCORE_HTTP_READY_QUEUE_IGNORES_PRIORITY
diff --git a/indra/llcorehttp/_httpreplyqueue.cpp b/indra/llcorehttp/_httpreplyqueue.cpp
index 912655d328..2b138f3ad5 100755
--- a/indra/llcorehttp/_httpreplyqueue.cpp
+++ b/indra/llcorehttp/_httpreplyqueue.cpp
@@ -45,16 +45,11 @@ HttpReplyQueue::HttpReplyQueue()
 
 HttpReplyQueue::~HttpReplyQueue()
 {
-	while (! mQueue.empty())
-	{
-		HttpOperation * op = mQueue.back();
-		mQueue.pop_back();
-		op->release();
-	}
+    mQueue.clear();
 }
 
 
-void HttpReplyQueue::addOp(HttpOperation * op)
+void HttpReplyQueue::addOp(const HttpReplyQueue::opPtr_t &op)
 {
 	{
 		HttpScopedLock lock(mQueueMutex);
@@ -65,15 +60,15 @@ void HttpReplyQueue::addOp(HttpOperation * op)
 }
 
 
-HttpOperation * HttpReplyQueue::fetchOp()
+HttpReplyQueue::opPtr_t HttpReplyQueue::fetchOp()
 {
-	HttpOperation * result(NULL);
+	HttpOperation::ptr_t result;
 
 	{
 		HttpScopedLock lock(mQueueMutex);
 
 		if (mQueue.empty())
-			return NULL;
+            return opPtr_t();
 
 		result = mQueue.front();
 		mQueue.erase(mQueue.begin());
@@ -97,9 +92,6 @@ void HttpReplyQueue::fetchAll(OpContainer & ops)
 			mQueue.swap(ops);
 		}
 	}
-
-	// Caller also acquires the reference counts on each op.
-	return;
 }
 
 
diff --git a/indra/llcorehttp/_httpreplyqueue.h b/indra/llcorehttp/_httpreplyqueue.h
index 7ad65c581f..0e39e22dde 100755
--- a/indra/llcorehttp/_httpreplyqueue.h
+++ b/indra/llcorehttp/_httpreplyqueue.h
@@ -62,13 +62,15 @@ class HttpReplyQueue : private boost::noncopyable
 {
 
 public:
+    typedef boost::shared_ptr<HttpOperation>    opPtr_t;
     typedef boost::shared_ptr<HttpReplyQueue>   ptr_t;
 
 	HttpReplyQueue();
     virtual ~HttpReplyQueue();		
 
 public:
-    typedef std::vector<HttpOperation *> OpContainer;
+
+    typedef std::vector< opPtr_t > OpContainer;
 
 	/// Insert an object at the back of the reply queue.
 	///
@@ -76,7 +78,7 @@ public:
 	/// through the queue.
 	///
 	/// Threading:  callable by any thread.
-	void addOp(HttpOperation * op);
+    void addOp(const opPtr_t &op);
 
 	/// Fetch an operation from the head of the queue.  Returns
 	/// NULL if none exists.
@@ -84,7 +86,7 @@ public:
 	/// Caller acquires reference count on returned operation.
 	///
 	/// Threading:  callable by any thread.
-	HttpOperation * fetchOp();
+    opPtr_t fetchOp();
 
 	/// Caller acquires reference count on each returned operation
 	///
diff --git a/indra/llcorehttp/_httprequestqueue.cpp b/indra/llcorehttp/_httprequestqueue.cpp
index c16966d078..c6f4ad789f 100755
--- a/indra/llcorehttp/_httprequestqueue.cpp
+++ b/indra/llcorehttp/_httprequestqueue.cpp
@@ -47,12 +47,7 @@ HttpRequestQueue::HttpRequestQueue()
 
 HttpRequestQueue::~HttpRequestQueue()
 {
-	while (! mQueue.empty())
-	{
-		HttpOperation * op = mQueue.back();
-		mQueue.pop_back();
-		op->release();
-	}
+    mQueue.clear();
 }
 
 
@@ -73,7 +68,7 @@ void HttpRequestQueue::term()
 }
 
 
-HttpStatus HttpRequestQueue::addOp(HttpOperation * op)
+HttpStatus HttpRequestQueue::addOp(const HttpRequestQueue::opPtr_t &op)
 {
 	bool wake(false);
 	{
@@ -95,9 +90,9 @@ HttpStatus HttpRequestQueue::addOp(HttpOperation * op)
 }
 
 
-HttpOperation * HttpRequestQueue::fetchOp(bool wait)
+HttpRequestQueue::opPtr_t HttpRequestQueue::fetchOp(bool wait)
 {
-	HttpOperation * result(NULL);
+	HttpOperation::ptr_t result;
 
 	{
 		HttpScopedLock lock(mQueueMutex);
@@ -105,7 +100,7 @@ HttpOperation * HttpRequestQueue::fetchOp(bool wait)
 		while (mQueue.empty())
 		{
 			if (! wait || mQueueStopped)
-				return NULL;
+                return HttpOperation::ptr_t();
 			mQueueCV.wait(lock);
 		}
 
diff --git a/indra/llcorehttp/_httprequestqueue.h b/indra/llcorehttp/_httprequestqueue.h
index c9c52b7233..3c3d134b07 100755
--- a/indra/llcorehttp/_httprequestqueue.h
+++ b/indra/llcorehttp/_httprequestqueue.h
@@ -61,6 +61,8 @@ private:
 	void operator=(const HttpRequestQueue &);			// Not defined
 
 public:
+    typedef boost::shared_ptr<HttpOperation> opPtr_t;
+
 	static void init();
 	static void term();
 	
@@ -71,7 +73,7 @@ public:
 		}
 	
 public:
-	typedef std::vector<HttpOperation *> OpContainer;
+    typedef std::vector<opPtr_t> OpContainer;
 
 	/// Insert an object at the back of the request queue.
 	///
@@ -83,7 +85,7 @@ public:
 	///					an explicit release() call.
 	///
 	/// Threading:  callable by any thread.
-	HttpStatus addOp(HttpOperation * op);
+    HttpStatus addOp(const opPtr_t &op);
 
 	/// Return the operation on the front of the queue.  If
 	/// the queue is empty and @wait is false, call returns
@@ -95,7 +97,7 @@ public:
 	/// Caller acquires reference count any returned operation
 	///
 	/// Threading:  callable by any thread.
-	HttpOperation * fetchOp(bool wait);
+    opPtr_t fetchOp(bool wait);
 
 	/// Return all queued requests to caller.  The @ops argument
 	/// should be empty when called and will be swap()'d with
diff --git a/indra/llcorehttp/_httpretryqueue.h b/indra/llcorehttp/_httpretryqueue.h
index 745adec09d..5d8c529cff 100755
--- a/indra/llcorehttp/_httpretryqueue.h
+++ b/indra/llcorehttp/_httpretryqueue.h
@@ -49,15 +49,15 @@ namespace LLCore
 
 struct HttpOpRetryCompare
 {
-	bool operator()(const HttpOpRequest * lhs, const HttpOpRequest * rhs)
+	bool operator()(const HttpOpRequest::ptr_t &lhs, const HttpOpRequest::ptr_t &rhs)
 		{
 			return lhs->mPolicyRetryAt < rhs->mPolicyRetryAt;
 		}
 };
 
 	
-typedef std::priority_queue<HttpOpRequest *,
-							std::deque<HttpOpRequest *>,
+typedef std::priority_queue<HttpOpRequest::ptr_t,
+							std::deque<HttpOpRequest::ptr_t>,
 							LLCore::HttpOpRetryCompare> HttpRetryQueueBase;
 
 class HttpRetryQueue : public HttpRetryQueueBase
diff --git a/indra/llcorehttp/_httpservice.cpp b/indra/llcorehttp/_httpservice.cpp
index 252db78c89..6c39fdc61b 100755
--- a/indra/llcorehttp/_httpservice.cpp
+++ b/indra/llcorehttp/_httpservice.cpp
@@ -263,14 +263,13 @@ void HttpService::shutdown()
 	// Cancel requests already on the request queue
 	HttpRequestQueue::OpContainer ops;
 	mRequestQueue->fetchAll(false, ops);
-	while (! ops.empty())
-	{
-		HttpOperation * op(ops.front());
-		ops.erase(ops.begin());
 
-		op->cancel();
-		op->release();
-	}
+    for (HttpRequestQueue::OpContainer::iterator it = ops.begin();
+        it != ops.end(); ++it)
+    {
+        (*it)->cancel();
+    }
+    ops.clear();
 
 	// Shutdown transport canceling requests, freeing resources
 	mTransport->shutdown();
@@ -324,7 +323,7 @@ HttpService::ELoopSpeed HttpService::processRequestQueue(ELoopSpeed loop)
 	mRequestQueue->fetchAll(wait_for_req, ops);
 	while (! ops.empty())
 	{
-		HttpOperation * op(ops.front());
+		HttpOperation::ptr_t op(ops.front());
 		ops.erase(ops.begin());
 
 		// Process operation
@@ -338,7 +337,7 @@ HttpService::ELoopSpeed HttpService::processRequestQueue(ELoopSpeed loop)
 			if (op->mTracing > HTTP_TRACE_OFF)
 			{
 				LL_INFOS(LOG_CORE) << "TRACE, FromRequestQueue, Handle:  "
-								   << static_cast<HttpHandle>(op)
+								   << op->getHandle()
 								   << LL_ENDL;
 			}
 
@@ -347,7 +346,7 @@ HttpService::ELoopSpeed HttpService::processRequestQueue(ELoopSpeed loop)
 		}
 				
 		// Done with operation
-		op->release();
+        op.reset();
 	}
 
 	// Queue emptied, allow polling loop to sleep
diff --git a/indra/llcorehttp/httpcommon.h b/indra/llcorehttp/httpcommon.h
index 1bc20fe6b5..b2db01d038 100755
--- a/indra/llcorehttp/httpcommon.h
+++ b/indra/llcorehttp/httpcommon.h
@@ -209,6 +209,7 @@ namespace LLCore
 /// becomes invalid and may be recycled for other queued requests.
 
 typedef void * HttpHandle;
+
 #define LLCORE_HTTP_HANDLE_INVALID		(NULL)
 
 /// For internal scheduling and metrics, we use a microsecond
diff --git a/indra/llcorehttp/httprequest.cpp b/indra/llcorehttp/httprequest.cpp
index 24e0f582e1..1c7994927b 100755
--- a/indra/llcorehttp/httprequest.cpp
+++ b/indra/llcorehttp/httprequest.cpp
@@ -127,27 +127,22 @@ HttpHandle HttpRequest::setPolicyOption(EPolicyOption opt, policy_t pclass,
 										long value, HttpHandler::ptr_t handler)
 {
 	HttpStatus status;
-	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-	HttpOpSetGet * op = new HttpOpSetGet();
+    HttpOpSetGet::ptr_t op(new HttpOpSetGet());
 	if (! (status = op->setupSet(opt, pclass, value)))
 	{
-		op->release();
 		mLastReqStatus = status;
-		return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
 	}
 	op->setReplyPath(mReplyQueue, handler);
 	if (! (status = mRequestQueue->addOp(op)))			// transfers refcount
 	{
-		op->release();
 		mLastReqStatus = status;
-		return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
 	}
 	
 	mLastReqStatus = status;
-	handle = static_cast<HttpHandle>(op);
-	
-	return handle;
+	return op->getHandle();
 }
 
 
@@ -155,27 +150,22 @@ HttpHandle HttpRequest::setPolicyOption(EPolicyOption opt, policy_t pclass,
 										const std::string & value, HttpHandler::ptr_t handler)
 {
 	HttpStatus status;
-	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-	HttpOpSetGet * op = new HttpOpSetGet();
+	HttpOpSetGet::ptr_t op (new HttpOpSetGet());
 	if (! (status = op->setupSet(opt, pclass, value)))
 	{
-		op->release();
 		mLastReqStatus = status;
-		return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
 	}
 	op->setReplyPath(mReplyQueue, handler);
 	if (! (status = mRequestQueue->addOp(op)))			// transfers refcount
 	{
-		op->release();
 		mLastReqStatus = status;
-		return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
 	}
 	
 	mLastReqStatus = status;
-	handle = static_cast<HttpHandle>(op);
-	
-	return handle;
+	return op->getHandle();
 }
 
 
@@ -198,27 +188,22 @@ HttpHandle HttpRequest::requestGet(policy_t policy_id,
 								   HttpHandler::ptr_t user_handler)
 {
 	HttpStatus status;
-	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-	HttpOpRequest * op = new HttpOpRequest();
+	HttpOpRequest::ptr_t op(new HttpOpRequest());
 	if (! (status = op->setupGet(policy_id, priority, url, options, headers)))
 	{
-		op->release();
 		mLastReqStatus = status;
-		return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
 	}
 	op->setReplyPath(mReplyQueue, user_handler);
 	if (! (status = mRequestQueue->addOp(op)))			// transfers refcount
 	{
-		op->release();
 		mLastReqStatus = status;
-		return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
 	}
 	
 	mLastReqStatus = status;
-	handle = static_cast<HttpHandle>(op);
-	
-	return handle;
+    return op->getHandle();
 }
 
 
@@ -232,27 +217,22 @@ HttpHandle HttpRequest::requestGetByteRange(policy_t policy_id,
 											HttpHandler::ptr_t user_handler)
 {
 	HttpStatus status;
-	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-	HttpOpRequest * op = new HttpOpRequest();
+	HttpOpRequest::ptr_t op(new HttpOpRequest());
 	if (! (status = op->setupGetByteRange(policy_id, priority, url, offset, len, options, headers)))
 	{
-		op->release();
 		mLastReqStatus = status;
-		return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
 	}
 	op->setReplyPath(mReplyQueue, user_handler);
 	if (! (status = mRequestQueue->addOp(op)))			// transfers refcount
 	{
-		op->release();
 		mLastReqStatus = status;
-		return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
 	}
 	
 	mLastReqStatus = status;
-	handle = static_cast<HttpHandle>(op);
-	
-	return handle;
+	return op->getHandle();
 }
 
 
@@ -265,27 +245,22 @@ HttpHandle HttpRequest::requestPost(policy_t policy_id,
 									HttpHandler::ptr_t user_handler)
 {
 	HttpStatus status;
-	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-	HttpOpRequest * op = new HttpOpRequest();
+	HttpOpRequest::ptr_t op(new HttpOpRequest());
 	if (! (status = op->setupPost(policy_id, priority, url, body, options, headers)))
 	{
-		op->release();
 		mLastReqStatus = status;
-		return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
 	}
 	op->setReplyPath(mReplyQueue, user_handler);
 	if (! (status = mRequestQueue->addOp(op)))			// transfers refcount
 	{
-		op->release();
 		mLastReqStatus = status;
-		return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
 	}
 	
 	mLastReqStatus = status;
-	handle = static_cast<HttpHandle>(op);
-	
-	return handle;
+	return op->getHandle();
 }
 
 
@@ -298,27 +273,22 @@ HttpHandle HttpRequest::requestPut(policy_t policy_id,
 								   HttpHandler::ptr_t user_handler)
 {
 	HttpStatus status;
-	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-	HttpOpRequest * op = new HttpOpRequest();
+	HttpOpRequest::ptr_t op (new HttpOpRequest());
 	if (! (status = op->setupPut(policy_id, priority, url, body, options, headers)))
 	{
-		op->release();
 		mLastReqStatus = status;
-		return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
 	}
 	op->setReplyPath(mReplyQueue, user_handler);
 	if (! (status = mRequestQueue->addOp(op)))			// transfers refcount
 	{
-		op->release();
 		mLastReqStatus = status;
-		return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
 	}
 	
 	mLastReqStatus = status;
-	handle = static_cast<HttpHandle>(op);
-	
-	return handle;
+    return op->getHandle();
 }
 
 HttpHandle HttpRequest::requestDelete(policy_t policy_id,
@@ -329,27 +299,22 @@ HttpHandle HttpRequest::requestDelete(policy_t policy_id,
     HttpHandler::ptr_t user_handler)
 {
     HttpStatus status;
-    HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-    HttpOpRequest * op = new HttpOpRequest();
+    HttpOpRequest::ptr_t op(new HttpOpRequest());
     if (!(status = op->setupDelete(policy_id, priority, url, options, headers)))
     {
-        op->release();
         mLastReqStatus = status;
-        return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
     }
     op->setReplyPath(mReplyQueue, user_handler);
     if (!(status = mRequestQueue->addOp(op)))			// transfers refcount
     {
-        op->release();
         mLastReqStatus = status;
-        return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
     }
 
     mLastReqStatus = status;
-    handle = static_cast<HttpHandle>(op);
-
-    return handle;
+    return op->getHandle();
 }
 
 HttpHandle HttpRequest::requestPatch(policy_t policy_id,
@@ -361,27 +326,22 @@ HttpHandle HttpRequest::requestPatch(policy_t policy_id,
     HttpHandler::ptr_t user_handler)
 {
     HttpStatus status;
-    HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-    HttpOpRequest * op = new HttpOpRequest();
+    HttpOpRequest::ptr_t op (new HttpOpRequest());
     if (!(status = op->setupPatch(policy_id, priority, url, body, options, headers)))
     {
-        op->release();
         mLastReqStatus = status;
-        return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
     }
     op->setReplyPath(mReplyQueue, user_handler);
     if (!(status = mRequestQueue->addOp(op)))			// transfers refcount
     {
-        op->release();
         mLastReqStatus = status;
-        return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
     }
 
     mLastReqStatus = status;
-    handle = static_cast<HttpHandle>(op);
-
-    return handle;
+    return op->getHandle();
 }
 
 HttpHandle HttpRequest::requestCopy(policy_t policy_id,
@@ -392,27 +352,23 @@ HttpHandle HttpRequest::requestCopy(policy_t policy_id,
     HttpHandler::ptr_t user_handler)
 {
     HttpStatus status;
-    HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-    HttpOpRequest * op = new HttpOpRequest();
+    HttpOpRequest::ptr_t op(new HttpOpRequest());
     if (!(status = op->setupCopy(policy_id, priority, url, options, headers)))
     {
-        op->release();
         mLastReqStatus = status;
-        return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
     }
     op->setReplyPath(mReplyQueue, user_handler);
     if (!(status = mRequestQueue->addOp(op)))			// transfers refcount
     {
-        op->release();
         mLastReqStatus = status;
-        return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
     }
 
     mLastReqStatus = status;
-    handle = static_cast<HttpHandle>(op);
+    return op->getHandle();
 
-    return handle;
 }
 
 HttpHandle HttpRequest::requestMove(policy_t policy_id,
@@ -423,54 +379,45 @@ HttpHandle HttpRequest::requestMove(policy_t policy_id,
     HttpHandler::ptr_t user_handler)
 {
     HttpStatus status;
-    HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-    HttpOpRequest * op = new HttpOpRequest();
+    HttpOpRequest::ptr_t op (new HttpOpRequest());
     if (!(status = op->setupMove(policy_id, priority, url, options, headers)))
     {
-        op->release();
         mLastReqStatus = status;
-        return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
     }
     op->setReplyPath(mReplyQueue, user_handler);
     if (!(status = mRequestQueue->addOp(op)))			// transfers refcount
     {
-        op->release();
         mLastReqStatus = status;
-        return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
     }
 
     mLastReqStatus = status;
-    handle = static_cast<HttpHandle>(op);
-
-    return handle;
+    return op->getHandle();
 }
 
 
 HttpHandle HttpRequest::requestNoOp(HttpHandler::ptr_t user_handler)
 {
 	HttpStatus status;
-	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-	HttpOpNull * op = new HttpOpNull();
+	HttpOperation::ptr_t op (new HttpOpNull());
 	op->setReplyPath(mReplyQueue, user_handler);
 	if (! (status = mRequestQueue->addOp(op)))			// transfers refcount
 	{
-		op->release();
 		mLastReqStatus = status;
-		return handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
 	}
 
 	mLastReqStatus = status;
-	handle = static_cast<HttpHandle>(op);
-	
-	return handle;
+	return op->getHandle();
 }
 
 
 HttpStatus HttpRequest::update(long usecs)
 {
-	HttpOperation * op(NULL);
+	HttpOperation::ptr_t op;
 	
 	if (usecs)
 	{
@@ -481,7 +428,7 @@ HttpStatus HttpRequest::update(long usecs)
 			op->visitNotifier(this);
 		
 			// We're done with the operation
-			op->release();
+            op.reset();
 		}
 	}
 	else
@@ -502,7 +449,7 @@ HttpStatus HttpRequest::update(long usecs)
 				op->visitNotifier(this);
 		
 				// We're done with the operation
-				op->release();
+                op.reset();
 			}
 		}
 	}
@@ -520,21 +467,17 @@ HttpStatus HttpRequest::update(long usecs)
 HttpHandle HttpRequest::requestCancel(HttpHandle request, HttpHandler::ptr_t user_handler)
 {
 	HttpStatus status;
-	HttpHandle ret_handle(LLCORE_HTTP_HANDLE_INVALID);
 
-	HttpOpCancel * op = new HttpOpCancel(request);
+	HttpOperation::ptr_t op(new HttpOpCancel(request));
 	op->setReplyPath(mReplyQueue, user_handler);
 	if (! (status = mRequestQueue->addOp(op)))			// transfers refcount
 	{
-		op->release();
 		mLastReqStatus = status;
-		return ret_handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
 	}
 
 	mLastReqStatus = status;
-	ret_handle = static_cast<HttpHandle>(op);
-	
-	return ret_handle;
+	return op->getHandle();
 }
 
 
@@ -542,21 +485,17 @@ HttpHandle HttpRequest::requestSetPriority(HttpHandle request, priority_t priori
 										   HttpHandler::ptr_t handler)
 {
 	HttpStatus status;
-	HttpHandle ret_handle(LLCORE_HTTP_HANDLE_INVALID);
 
-	HttpOpSetPriority * op = new HttpOpSetPriority(request, priority);
+	HttpOperation::ptr_t op (new HttpOpSetPriority(request, priority));
 	op->setReplyPath(mReplyQueue, handler);
 	if (! (status = mRequestQueue->addOp(op)))			// transfers refcount
 	{
-		op->release();
 		mLastReqStatus = status;
-		return ret_handle;
+        return LLCORE_HTTP_HANDLE_INVALID;
 	}
 
 	mLastReqStatus = status;
-	ret_handle = static_cast<HttpHandle>(op);
-	
-	return ret_handle;
+	return op->getHandle();
 }
 
 
@@ -610,17 +549,16 @@ HttpHandle HttpRequest::requestStopThread(HttpHandler::ptr_t user_handler)
 	HttpStatus status;
 	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-	HttpOpStop * op = new HttpOpStop();
+	HttpOperation::ptr_t op(new HttpOpStop());
 	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);
+	handle = op->getHandle();
 
 	return handle;
 }
@@ -631,17 +569,16 @@ HttpHandle HttpRequest::requestSpin(int mode)
 	HttpStatus status;
 	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
-	HttpOpSpin * op = new HttpOpSpin(mode);
+	HttpOperation::ptr_t op(new HttpOpSpin(mode));
     op->setReplyPath(mReplyQueue, HttpHandler::ptr_t());
 	if (! (status = mRequestQueue->addOp(op)))			// transfers refcount
 	{
-		op->release();
 		mLastReqStatus = status;
 		return handle;
 	}
 
 	mLastReqStatus = status;
-	handle = static_cast<HttpHandle>(op);
+	handle = op->getHandle();
 
 	return handle;
 }
diff --git a/indra/llcorehttp/httprequest.h b/indra/llcorehttp/httprequest.h
index 2eb3caa11e..17cfdcd7b6 100755
--- a/indra/llcorehttp/httprequest.h
+++ b/indra/llcorehttp/httprequest.h
@@ -655,7 +655,6 @@ public:
 	/// @}
 	
 protected:
-	void generateNotification(HttpOperation * op);
 
 private:
     typedef boost::shared_ptr<HttpReplyQueue> HttpReplyQueuePtr_t;
diff --git a/indra/llcorehttp/tests/test_httpoperation.hpp b/indra/llcorehttp/tests/test_httpoperation.hpp
index 890e5fdd9c..e7df2337de 100755
--- a/indra/llcorehttp/tests/test_httpoperation.hpp
+++ b/indra/llcorehttp/tests/test_httpoperation.hpp
@@ -76,12 +76,12 @@ namespace tut
 		mMemTotal = GetMemTotal();
 
 		// create a new ref counted object with an implicit reference
-		HttpOpNull * op = new HttpOpNull();
-		ensure(op->getRefCount() == 1);
+		HttpOperation::ptr_t op (new HttpOpNull());
+		ensure(op.use_count() == 1);
 		ensure(mMemTotal < GetMemTotal());
 		
 		// release the implicit reference, causing the object to be released
-		op->release();
+        op.reset();
 
 		// make sure we didn't leak any memory
 		ensure(mMemTotal == GetMemTotal());
@@ -99,18 +99,17 @@ namespace tut
 		LLCore::HttpHandler::ptr_t h1 (new TestHandler());
 		
 		// create a new ref counted object with an implicit reference
-		HttpOpNull * op = new HttpOpNull();
+		HttpOperation::ptr_t op (new HttpOpNull());
 
 		// Add the handlers
 		op->setReplyPath(LLCore::HttpOperation::HttpReplyQueuePtr_t(), h1);
 
 		// Check ref count
-		ensure(op->getRefCount() == 1);
+		ensure(op.unique() == 1);
 
 		// release the reference, releasing the operation but
 		// not the handlers.
-		op->release();
-		op = NULL;
+        op.reset();
 		ensure(mMemTotal != GetMemTotal());
 		
 		// release the handlers
diff --git a/indra/llcorehttp/tests/test_httprequestqueue.hpp b/indra/llcorehttp/tests/test_httprequestqueue.hpp
index 1de2d8f9ab..ef4ce0479b 100755
--- a/indra/llcorehttp/tests/test_httprequestqueue.hpp
+++ b/indra/llcorehttp/tests/test_httprequestqueue.hpp
@@ -113,16 +113,16 @@ void HttpRequestqueueTestObjectType::test<3>()
 
 	HttpRequestQueue * rq = HttpRequestQueue::instanceOf();
 
-	HttpOperation * op = new HttpOpNull();
+	HttpOperation::ptr_t op(new HttpOpNull());
 
 	rq->addOp(op);		// transfer my refcount
 
 	op = rq->fetchOp(true);		// Potentially hangs the test on failure
-	ensure("One goes in, one comes out", NULL != op);
-	op->release();
+	ensure("One goes in, one comes out", static_cast<bool>(op));
+    op.reset();
 
 	op = rq->fetchOp(false);
-	ensure("Better not be two of them", NULL == op);
+	ensure("Better not be two of them", !op);
 	
 	// release the singleton, hold on to the object
 	HttpRequestQueue::term();
@@ -144,13 +144,13 @@ void HttpRequestqueueTestObjectType::test<4>()
 
 	HttpRequestQueue * rq = HttpRequestQueue::instanceOf();
 
-	HttpOperation * op = new HttpOpNull();
+	HttpOperation::ptr_t op (new HttpOpNull());
 	rq->addOp(op);		// transfer my refcount
 
-	op = new HttpOpNull();
+	op.reset(new HttpOpNull());
 	rq->addOp(op);		// transfer my refcount
 
-	op = new HttpOpNull();
+	op.reset(new HttpOpNull());
 	rq->addOp(op);		// transfer my refcount
 	
 	{
@@ -159,8 +159,9 @@ void HttpRequestqueueTestObjectType::test<4>()
 		ensure("Three go in, three come out", 3 == ops.size());
 
 		op = rq->fetchOp(false);
-		ensure("Better not be any more of them", NULL == op);
-	
+		ensure("Better not be any more of them", !op);
+        op.reset();
+
 		// release the singleton, hold on to the object
 		HttpRequestQueue::term();
 	
@@ -168,12 +169,13 @@ void HttpRequestqueueTestObjectType::test<4>()
 		ensure(mMemTotal < GetMemTotal());
 
 		// Release them
-		while (! ops.empty())
-		{
-			HttpOperation * op = ops.front();
-			ops.erase(ops.begin());
-			op->release();
-		}
+        ops.clear();
+// 		while (! ops.empty())
+// 		{
+// 			HttpOperation * op = ops.front();
+// 			ops.erase(ops.begin());
+// 			op->release();
+// 		}
 	}
 
 	// Should be clean