Convert some elements to STL

4 files changed, 153 insertions, 114 deletions

diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt
index 13436ecb16..c9bcd17d96 100755
--- a/indra/newview/CMakeLists.txt
+++ b/indra/newview/CMakeLists.txt
@@ -2352,7 +2352,7 @@ if (LL_TESTS)
     ${BOOST_COROUTINE_LIBRARY}
   )
 
-    LL_ADD_INTEGRATION_TEST(llsechandler_basic
+  LL_ADD_INTEGRATION_TEST(llsechandler_basic
     llsechandler_basic.cpp
     "${test_libs}"
     )
diff --git a/indra/newview/llmediadataclient.cpp b/indra/newview/llmediadataclient.cpp
index 2a53e3fe78..770a37c275 100755
--- a/indra/newview/llmediadataclient.cpp
+++ b/indra/newview/llmediadataclient.cpp
@@ -33,6 +33,7 @@
 #pragma warning (disable:4702)
 #endif
 
+#include <algorithm>
 #include <boost/lexical_cast.hpp>
 
 #include "llhttpconstants.h"
@@ -92,52 +93,73 @@ const U32 LLMediaDataClient::MAX_ROUND_ROBIN_QUEUE_SIZE = 10000;
 std::ostream& operator<<(std::ostream &s, const LLMediaDataClient::request_queue_t &q);
 std::ostream& operator<<(std::ostream &s, const LLMediaDataClient::Request &q);
 
-template <typename T>
-typename T::iterator find_matching_request(T &c, const LLMediaDataClient::Request *request, LLMediaDataClient::Request::Type match_type)
+
+//=========================================================================
+/// Uniary Predicate for matching requests in collections by either the request
+/// or by UUID
+/// 
+class PredicateMatchRequest
 {
-	for(typename T::iterator iter = c.begin(); iter != c.end(); ++iter)
-	{
-		if(request->isMatch(*iter, match_type))
-		{
-			return iter;
-		}
-	}
-	
-	return c.end();
+public:
+    PredicateMatchRequest(const LLMediaDataClient::Request::ptr_t &request, LLMediaDataClient::Request::Type matchType = LLMediaDataClient::Request::ANY);
+    PredicateMatchRequest(const LLUUID &id, LLMediaDataClient::Request::Type matchType = LLMediaDataClient::Request::ANY);
+
+    PredicateMatchRequest(const PredicateMatchRequest &other);
+
+    bool operator()(const LLMediaDataClient::Request::ptr_t &test) const;
+
+private:
+    LLMediaDataClient::Request::ptr_t mRequest;
+    LLMediaDataClient::Request::Type  mMatchType;
+    LLUUID                            mId;
+};
+
+
+PredicateMatchRequest::PredicateMatchRequest(const LLMediaDataClient::Request::ptr_t &request, LLMediaDataClient::Request::Type matchType) :
+    mRequest(request),
+    mMatchType(matchType),
+    mId()
+{}
+    
+PredicateMatchRequest::PredicateMatchRequest(const LLUUID &id, LLMediaDataClient::Request::Type matchType) :
+    mRequest(),
+    mMatchType(matchType),
+    mId(id)
+{}
+
+PredicateMatchRequest::PredicateMatchRequest(const PredicateMatchRequest &other)
+{
+    mRequest = other.mRequest;
+    mMatchType = other.mMatchType;
+    mId = other.mId;
 }
 
-template <typename T>
-typename T::iterator find_matching_request(T &c, const LLUUID &id, LLMediaDataClient::Request::Type match_type)
+bool PredicateMatchRequest::operator()(const LLMediaDataClient::Request::ptr_t &test) const
 {
-	for(typename T::iterator iter = c.begin(); iter != c.end(); ++iter)
-	{
-		if(((*iter)->getID() == id) && ((match_type == LLMediaDataClient::Request::ANY) || (match_type == (*iter)->getType())))
-		{
-			return iter;
-		}
-	}
-	
-	return c.end();
+    if (mRequest)
+        return (mRequest->isMatch(test, mMatchType));
+    else if (!mId.isNull())
+        return ((test->getID() == mId) && ((mMatchType == LLMediaDataClient::Request::ANY) || (mMatchType == test->getType())));
+    return false;
 }
 
-// NOTE: remove_matching_requests will not work correctly for containers where deleting an element may invalidate iterators
-// to other elements in the container (such as std::vector).
-// If the implementation is changed to use a container with this property, this will need to be revisited.
+//=========================================================================
+/// 
 template <typename T>
-void remove_matching_requests(T &c, const LLUUID &id, LLMediaDataClient::Request::Type match_type)
+void mark_dead_and_remove_if(T &c, const PredicateMatchRequest &matchPred)
 {
-	for(typename T::iterator iter = c.begin(); iter != c.end();)
-	{
-		typename T::value_type i = *iter;
-		typename T::iterator next = iter;
-		next++;
-		if((i->getID() == id) && ((match_type == LLMediaDataClient::Request::ANY) || (match_type == i->getType())))
-		{
-			i->markDead();
-			c.erase(iter);
-		}
-		iter = next;
-	}
+    for (typename T::iterator it = c.begin(); it != c.end();)
+    {
+        if (matchPred(*it))
+        {
+            (*it)->markDead();
+            it = c.erase(it);
+        }
+        else
+        {
+            ++it;
+        }
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
@@ -174,20 +196,23 @@ bool LLMediaDataClient::isEmpty() const
 
 bool LLMediaDataClient::isInQueue(const LLMediaDataClientObject::ptr_t &object)
 {
-	if(find_matching_request(mQueue, object->getID(), LLMediaDataClient::Request::ANY) != mQueue.end())
-		return true;
-	
-	if(find_matching_request(mUnQueuedRequests, object->getID(), LLMediaDataClient::Request::ANY) != mUnQueuedRequests.end())
-		return true;
-	
+    PredicateMatchRequest upred(object->getID());
+
+    if (std::find_if(mQueue.begin(), mQueue.end(), upred) != mQueue.end())
+        return true;
+    if (std::find_if(mUnQueuedRequests.begin(), mUnQueuedRequests.end(), upred) != mUnQueuedRequests.end())
+        return true;
+    
 	return false;
 }
 
 void LLMediaDataClient::removeFromQueue(const LLMediaDataClientObject::ptr_t &object)
 {
 	LL_DEBUGS("LLMediaDataClient") << "removing requests matching ID " << object->getID() << LL_ENDL;
-	remove_matching_requests(mQueue, object->getID(), LLMediaDataClient::Request::ANY);
-	remove_matching_requests(mUnQueuedRequests, object->getID(), LLMediaDataClient::Request::ANY);
+    PredicateMatchRequest upred(object->getID());
+
+    mark_dead_and_remove_if(mQueue, upred);
+    mark_dead_and_remove_if(mUnQueuedRequests, upred);
 }
 
 void LLMediaDataClient::startQueueTimer() 
@@ -225,9 +250,9 @@ bool LLMediaDataClient::processQueueTimer()
     return isDoneProcessing();
 }
 
-LLMediaDataClient::request_ptr_t LLMediaDataClient::dequeue()
+LLMediaDataClient::Request::ptr_t LLMediaDataClient::dequeue()
 {
-	request_ptr_t request;
+	Request::ptr_t request;
 	request_queue_t *queue_p = getQueue();
 	
 	if (queue_p->empty())
@@ -253,13 +278,13 @@ LLMediaDataClient::request_ptr_t LLMediaDataClient::dequeue()
 	return request;
 }
 
-void LLMediaDataClient::pushBack(request_ptr_t request)
+void LLMediaDataClient::pushBack(Request::ptr_t request)
 {
 	request_queue_t *queue_p = getQueue();
 	queue_p->push_front(request);
 }
 
-void LLMediaDataClient::trackRequest(request_ptr_t request)
+void LLMediaDataClient::trackRequest(Request::ptr_t request)
 {
 	request_set_t::iterator iter = mUnQueuedRequests.find(request);
 	
@@ -273,7 +298,7 @@ void LLMediaDataClient::trackRequest(request_ptr_t request)
 	}
 }
 
-void LLMediaDataClient::stopTrackingRequest(request_ptr_t request)
+void LLMediaDataClient::stopTrackingRequest(Request::ptr_t request)
 {
 	request_set_t::iterator iter = mUnQueuedRequests.find(request);
 	
@@ -296,13 +321,13 @@ bool LLMediaDataClient::isDoneProcessing() const
 void LLMediaDataClient::serviceQueue()
 {	
 	// Peel one off of the items from the queue and execute it
-	request_ptr_t request;
+	Request::ptr_t request;
 	
 	do
 	{
 		request = dequeue();
 
-		if(request.isNull())
+		if(!request)
 		{
 			// Queue is empty.
 			return;
@@ -420,7 +445,7 @@ BOOL LLMediaDataClient::QueueTimer::tick()
 //
 //////////////////////////////////////////////////////////////////////////////////////
 
-LLMediaDataClient::RetryTimer::RetryTimer(F32 time, request_ptr_t request)
+LLMediaDataClient::RetryTimer::RetryTimer(F32 time, Request::ptr_t request)
 : LLEventTimer(time), mRequest(request)
 {
 	mRequest->startTracking();
@@ -515,7 +540,7 @@ void LLMediaDataClient::Request::reEnqueue()
 {
 	if(mMDC)
 	{
-		mMDC->enqueue(this);
+		mMDC->enqueue(shared_from_this());
 	}
 }
 
@@ -558,13 +583,13 @@ bool LLMediaDataClient::Request::isDead()
 void LLMediaDataClient::Request::startTracking() 
 { 
 	if(mMDC) 
-		mMDC->trackRequest(this); 
+        mMDC->trackRequest(shared_from_this());
 }
 
 void LLMediaDataClient::Request::stopTracking() 
 { 
 	if(mMDC) 
-		mMDC->stopTrackingRequest(this); 
+        mMDC->stopTrackingRequest(shared_from_this());
 }
 
 std::ostream& operator<<(std::ostream &s, const LLMediaDataClient::Request &r)
@@ -579,7 +604,7 @@ std::ostream& operator<<(std::ostream &s, const LLMediaDataClient::Request &r)
 
 //========================================================================
 
-LLMediaDataClient::Handler::Handler(const request_ptr_t &request):
+LLMediaDataClient::Handler::Handler(const Request::ptr_t &request):
     mRequest(request)
 {
 }
@@ -647,7 +672,7 @@ void LLMediaDataClient::Handler::onFailure(LLCore::HttpResponse * response, LLCo
 void LLObjectMediaDataClient::fetchMedia(LLMediaDataClientObject *object)
 {
 	// Create a get request and put it in the queue.
-	enqueue(new RequestGet(object, this));
+	enqueue(Request::ptr_t(new RequestGet(object, this)));
 }
 
 const char *LLObjectMediaDataClient::getCapabilityName() const 
@@ -691,14 +716,14 @@ void LLObjectMediaDataClient::sortQueue()
 }
 
 // static
-bool LLObjectMediaDataClient::compareRequestScores(const request_ptr_t &o1, const request_ptr_t &o2)
+bool LLObjectMediaDataClient::compareRequestScores(const Request::ptr_t &o1, const Request::ptr_t &o2)
 {
-	if (o2.isNull()) return true;
-	if (o1.isNull()) return false;
+	if (!o2) return true;
+	if (!o1) return false;
 	return ( o1->getScore() > o2->getScore() );
 }
 
-void LLObjectMediaDataClient::enqueue(Request *request)
+void LLObjectMediaDataClient::enqueue(Request::ptr_t request)
 {
 	if(request->isDead())
 	{
@@ -716,9 +741,10 @@ void LLObjectMediaDataClient::enqueue(Request *request)
 	{
 		// For GET requests that are not new, if a matching request is already in the round robin queue, 
 		// in flight, or being retried, leave it at its current position.
-		request_queue_t::iterator iter = find_matching_request(mRoundRobinQueue, request->getID(), Request::GET);
-		request_set_t::iterator iter2 = find_matching_request(mUnQueuedRequests, request->getID(), Request::GET);
-		
+        PredicateMatchRequest upred(request->getID(), Request::GET);
+        request_queue_t::iterator iter = std::find_if(mRoundRobinQueue.begin(), mRoundRobinQueue.end(), upred);
+        request_set_t::iterator iter2 = std::find_if(mUnQueuedRequests.begin(), mUnQueuedRequests.end(), upred);
+
 		if( (iter != mRoundRobinQueue.end()) || (iter2 != mUnQueuedRequests.end()) )
 		{
 			LL_DEBUGS("LLMediaDataClient") << "ALREADY THERE: NOT Queuing request for " << *request << LL_ENDL;
@@ -731,9 +757,11 @@ void LLObjectMediaDataClient::enqueue(Request *request)
 	// IF the update will cause an object update message to be sent out at some point in the future, it probably should.
 	
 	// Remove any existing requests of this type for this object
-	remove_matching_requests(mQueue, request->getID(), request->getType());
-	remove_matching_requests(mRoundRobinQueue, request->getID(), request->getType());
-	remove_matching_requests(mUnQueuedRequests, request->getID(), request->getType());
+    PredicateMatchRequest upred(request->getID(), request->getType());
+
+    mark_dead_and_remove_if(mQueue, upred);
+    mark_dead_and_remove_if(mRoundRobinQueue, upred);
+    mark_dead_and_remove_if(mUnQueuedRequests, upred);
 
 	if (is_new)
 	{
@@ -762,7 +790,7 @@ void LLObjectMediaDataClient::enqueue(Request *request)
 	startQueueTimer();
 }
 
-bool LLObjectMediaDataClient::canServiceRequest(request_ptr_t request) 
+bool LLObjectMediaDataClient::canServiceRequest(Request::ptr_t request) 
 {
 	if(mCurrentQueueIsTheSortedQueue)
 	{
@@ -798,9 +826,9 @@ bool LLObjectMediaDataClient::isInQueue(const LLMediaDataClientObject::ptr_t &ob
 	if(LLMediaDataClient::isInQueue(object))
 		return true;
 
-	if(find_matching_request(mRoundRobinQueue, object->getID(), LLMediaDataClient::Request::ANY) != mRoundRobinQueue.end())
-		return true;
-	
+    if (std::find_if(mRoundRobinQueue.begin(), mRoundRobinQueue.end(), PredicateMatchRequest(object->getID())) != mRoundRobinQueue.end())
+        return true;
+
 	return false;
 }
 
@@ -809,7 +837,7 @@ void LLObjectMediaDataClient::removeFromQueue(const LLMediaDataClientObject::ptr
 	// First, call parent impl.
 	LLMediaDataClient::removeFromQueue(object);
 	
-	remove_matching_requests(mRoundRobinQueue, object->getID(), LLMediaDataClient::Request::ANY);
+    mark_dead_and_remove_if(mRoundRobinQueue, PredicateMatchRequest(object->getID()));
 }
 
 bool LLObjectMediaDataClient::processQueueTimer()
@@ -857,14 +885,14 @@ LLSD LLObjectMediaDataClient::RequestGet::getPayload() const
 
 LLHttpSDHandler *LLObjectMediaDataClient::RequestGet::createHandler()
 {
-	return new LLObjectMediaDataClient::Handler(this);
+	return new LLObjectMediaDataClient::Handler(shared_from_this());
 }
 
 
 void LLObjectMediaDataClient::updateMedia(LLMediaDataClientObject *object)
 {
 	// Create an update request and put it in the queue.
-	enqueue(new RequestUpdate(object, this));
+	enqueue(Request::ptr_t(new RequestUpdate(object, this)));
 }
 
 LLObjectMediaDataClient::RequestUpdate::RequestUpdate(LLMediaDataClientObject *obj, LLMediaDataClient *mdc):
@@ -894,7 +922,7 @@ LLSD LLObjectMediaDataClient::RequestUpdate::getPayload() const
 LLHttpSDHandler *LLObjectMediaDataClient::RequestUpdate::createHandler()
 {
 	// This just uses the base class's responder.
-	return new LLMediaDataClient::Handler(this);
+	return new LLMediaDataClient::Handler(shared_from_this());
 }
 
 void LLObjectMediaDataClient::Handler::onSuccess(LLCore::HttpResponse * response, const LLSD &content)
@@ -955,7 +983,7 @@ const char *LLObjectMediaNavigateClient::getCapabilityName() const
 	return "ObjectMediaNavigate";
 }
 
-void LLObjectMediaNavigateClient::enqueue(Request *request)
+void LLObjectMediaNavigateClient::enqueue(Request::ptr_t request)
 {
 	if(request->isDead())
 	{
@@ -963,8 +991,10 @@ void LLObjectMediaNavigateClient::enqueue(Request *request)
 		return;
 	}
 	
+    PredicateMatchRequest upred(request);
+
 	// If there's already a matching request in the queue, remove it.
-	request_queue_t::iterator iter = find_matching_request(mQueue, request, LLMediaDataClient::Request::ANY);
+    request_queue_t::iterator iter = std::find_if(mQueue.begin(), mQueue.end(), upred);
 	if(iter != mQueue.end())
 	{
 		LL_DEBUGS("LLMediaDataClient") << "removing matching queued request " << (**iter) << LL_ENDL;
@@ -972,7 +1002,7 @@ void LLObjectMediaNavigateClient::enqueue(Request *request)
 	}
 	else
 	{
-		request_set_t::iterator set_iter = find_matching_request(mUnQueuedRequests, request, LLMediaDataClient::Request::ANY);
+        request_set_t::iterator set_iter = std::find_if(mUnQueuedRequests.begin(), mUnQueuedRequests.end(), upred);
 		if(set_iter != mUnQueuedRequests.end())
 		{
 			LL_DEBUGS("LLMediaDataClient") << "removing matching unqueued request " << (**set_iter) << LL_ENDL;
@@ -1005,7 +1035,7 @@ void LLObjectMediaNavigateClient::navigate(LLMediaDataClientObject *object, U8 t
 //	LL_INFOS("LLMediaDataClient") << "navigate() initiated: " << ll_print_sd(sd_payload) << LL_ENDL;
 	
 	// Create a get request and put it in the queue.
-	enqueue(new RequestNavigate(object, this, texture_index, url));
+	enqueue(Request::ptr_t(new RequestNavigate(object, this, texture_index, url)));
 }
 
 LLObjectMediaNavigateClient::RequestNavigate::RequestNavigate(LLMediaDataClientObject *obj, LLMediaDataClient *mdc, U8 texture_index, const std::string &url):
@@ -1026,7 +1056,7 @@ LLSD LLObjectMediaNavigateClient::RequestNavigate::getPayload() const
 
 LLHttpSDHandler *LLObjectMediaNavigateClient::RequestNavigate::createHandler()
 {
-	return new LLObjectMediaNavigateClient::Handler(this);
+	return new LLObjectMediaNavigateClient::Handler(shared_from_this());
 }
 
 void LLObjectMediaNavigateClient::Handler::onSuccess(LLCore::HttpResponse * response, const LLSD &content)
diff --git a/indra/newview/llmediadataclient.h b/indra/newview/llmediadataclient.h
index d123aa7a11..2c0aedb1d9 100755
--- a/indra/newview/llmediadataclient.h
+++ b/indra/newview/llmediadataclient.h
@@ -78,6 +78,8 @@ public:
 // Abstracts the Cap URL, the request, and the responder
 class LLMediaDataClient : public LLRefCount
 {
+    friend class PredicateMatchRequest;
+
 protected:
     LOG_CLASS(LLMediaDataClient);
 public:
@@ -114,23 +116,29 @@ protected:
 	virtual ~LLMediaDataClient(); // use unref
     
 	// Request (pure virtual base class for requests in the queue)
-	class Request : public LLRefCount
-	{
-	public:
-		// 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.
+    class Request: 
+        public boost::enable_shared_from_this<Request>
+    {
+    public:
+        typedef boost::shared_ptr<Request> ptr_t;
+
+        // 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 LLHttpSDHandler *createHandler() = 0;
 
-		virtual std::string getURL() { return ""; }
+        virtual std::string getURL() { return ""; }
 
         enum Type {
             GET,
             UPDATE,
             NAVIGATE,
-			ANY
+            ANY
         };
-        
+
+        virtual ~Request()
+        { }
+
 	protected:
 		// The only way to create one of these is through a subclass.
 		Request(Type in_type, LLMediaDataClientObject *obj, LLMediaDataClient *mdc, S32 face = -1);
@@ -168,7 +176,7 @@ protected:
 		const LLUUID &getID() const { return mObjectID; }
 		S32 getFace() const { return mFace; }
 		
-		bool isMatch (const Request* other, Type match_type = ANY) const 
+		bool isMatch (const Request::ptr_t &other, Type match_type = ANY) const 
 		{ 
 			return ((match_type == ANY) || (mType == other->mType)) && 
 					(mFace == other->mFace) && 
@@ -190,44 +198,44 @@ protected:
 		// Back pointer to the MDC...not a ref!
 		LLMediaDataClient *mMDC;
 	};
-	typedef LLPointer<Request> request_ptr_t;
+	//typedef LLPointer<Request> request_ptr_t;
 
     class Handler : public LLHttpSDHandler
     {
         LOG_CLASS(Handler);
     public:
-        Handler(const request_ptr_t &request);
-        request_ptr_t getRequest() const { return mRequest; }
+        Handler(const Request::ptr_t &request);
+        Request::ptr_t getRequest() const { return mRequest; }
 
     protected:
         virtual void onSuccess(LLCore::HttpResponse * response, const LLSD &content);
         virtual void onFailure(LLCore::HttpResponse * response, LLCore::HttpStatus status);
 
     private:
-        request_ptr_t mRequest;
+        Request::ptr_t mRequest;
     };
 
 
 	class RetryTimer : public LLEventTimer
 	{
 	public:
-		RetryTimer(F32 time, request_ptr_t);
+		RetryTimer(F32 time, Request::ptr_t);
 		virtual BOOL tick();
 	private:
 		// back-pointer
-		request_ptr_t mRequest;
+		Request::ptr_t mRequest;
 	};
 		
 	
 protected:
-	typedef std::list<request_ptr_t> request_queue_t;
-	typedef std::set<request_ptr_t> request_set_t;
+	typedef std::list<Request::ptr_t> request_queue_t;
+	typedef std::set<Request::ptr_t> request_set_t;
 
 	// Subclasses must override to return a cap name
 	virtual const char *getCapabilityName() const = 0;
 
 	// Puts the request into a queue, appropriately handling duplicates, etc.
-	virtual void enqueue(Request*) = 0;
+    virtual void enqueue(Request::ptr_t) = 0;
 	
 	virtual void serviceQueue();
     virtual void serviceHttp();
@@ -235,15 +243,15 @@ protected:
 	virtual request_queue_t *getQueue() { return &mQueue; };
 
 	// Gets the next request, removing it from the queue
-	virtual request_ptr_t dequeue();
+	virtual Request::ptr_t dequeue();
 	
-	virtual bool canServiceRequest(request_ptr_t request) { return true; };
+	virtual bool canServiceRequest(Request::ptr_t request) { return true; };
 
 	// Returns a request to the head of the queue (should only be used for requests that came from dequeue
-	virtual void pushBack(request_ptr_t request);
+	virtual void pushBack(Request::ptr_t request);
 	
-	void trackRequest(request_ptr_t request);
-	void stopTrackingRequest(request_ptr_t request);
+	void trackRequest(Request::ptr_t request);
+	void stopTrackingRequest(Request::ptr_t request);
 
     bool isDoneProcessing() const;
 	
@@ -339,7 +347,7 @@ public:
 
 	virtual bool processQueueTimer();
 
-	virtual bool canServiceRequest(request_ptr_t request);
+	virtual bool canServiceRequest(Request::ptr_t request);
 
 protected:
 	// Subclasses must override to return a cap name
@@ -348,13 +356,13 @@ protected:
 	virtual request_queue_t *getQueue();
 
 	// Puts the request into the appropriate queue
-	virtual void enqueue(Request*);
+	virtual void enqueue(Request::ptr_t);
 		    
     class Handler: public LLMediaDataClient::Handler
     {
         LOG_CLASS(Handler);
     public:
-        Handler(const request_ptr_t &request):
+        Handler(const Request::ptr_t &request):
             LLMediaDataClient::Handler(request)
         {}
 
@@ -370,7 +378,7 @@ private:
 	bool mCurrentQueueIsTheSortedQueue;
 
 	// Comparator for sorting
-	static bool compareRequestScores(const request_ptr_t &o1, const request_ptr_t &o2);
+	static bool compareRequestScores(const Request::ptr_t &o1, const Request::ptr_t &o2);
 	void sortQueue();
 };
 
@@ -395,7 +403,7 @@ public:
     void navigate(LLMediaDataClientObject *object, U8 texture_index, const std::string &url);
 
 	// Puts the request into the appropriate queue
-	virtual void enqueue(Request*);
+    virtual void enqueue(Request::ptr_t);
 
 	class RequestNavigate: public Request
 	{
@@ -416,7 +424,7 @@ protected:
     {
         LOG_CLASS(Handler);
     public:
-        Handler(const request_ptr_t &request):
+        Handler(const Request::ptr_t &request):
             LLMediaDataClient::Handler(request)
         {}
 
diff --git a/indra/newview/tests/llmediadataclient_test.cpp b/indra/newview/tests/llmediadataclient_test.cpp
index 6f57daf151..61120686e4 100755
--- a/indra/newview/tests/llmediadataclient_test.cpp
+++ b/indra/newview/tests/llmediadataclient_test.cpp
@@ -106,7 +106,7 @@ const char *DATA = _DATA(VALID_OBJECT_ID,"1.0","true");
 
 LLSD *gPostRecords = NULL;
 F64   gMinimumInterestLevel = (F64)0.0;
-
+#if 0
 // stubs:
 void LLHTTPClient::post(
 		const std::string& url,
@@ -140,6 +140,7 @@ void LLHTTPClient::post(
 	}
 	responder->successResult(result);
 }
+#endif
 
 const F32 HTTP_REQUEST_EXPIRY_SECS = 60.0f;