path: root/indra/newview/llmediadataclient.cpp

/** 
 * @file llmediadataclient.cpp
 * @brief class for queueing up requests for media data
 *
 * $LicenseInfo:firstyear=2001&license=viewergpl$
 * 
 * Copyright (c) 2001-2009, Linden Research, Inc.
 * 
 * Second Life Viewer Source Code
 * The source code in this file ("Source Code") is provided by Linden Lab
 * to you under the terms of the GNU General Public License, version 2.0
 * ("GPL"), unless you have obtained a separate licensing agreement
 * ("Other License"), formally executed by you and Linden Lab.	Terms of
 * the GPL can be found in doc/GPL-license.txt in this distribution, or
 * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
 * 
 * There are special exceptions to the terms and conditions of the GPL as
 * it is applied to this Source Code. View the full text of the exception
 * in the file doc/FLOSS-exception.txt in this software distribution, or
 * online at
 * http://secondlifegrid.net/programs/open_source/licensing/flossexception
 * 
 * By copying, modifying or distributing this software, you acknowledge
 * that you have read and understood your obligations described above,
 * and agree to abide by those obligations.
 * 
 * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
 * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
 * COMPLETENESS OR PERFORMANCE.
 * $/LicenseInfo$
 */

#include "llviewerprecompiledheaders.h"

#include "llmediadataclient.h"

#if LL_MSVC
// disable boost::lexical_cast warning
#pragma warning (disable:4702)
#endif

#include <boost/lexical_cast.hpp>

#include "llhttpstatuscodes.h"
#include "llsdutil.h"
#include "llmediaentry.h"
#include "lltextureentry.h"
#include "llviewerregion.h"

//
// When making a request
// - obtain the "overall interest score" of the object.	 
//	 This would be the sum of the impls' interest scores.
// - put the request onto a queue sorted by this score 
//	 (highest score at the front of the queue)
// - On a timer, once a second, pull off the head of the queue and send 
//	 the request.
// - Any request that gets a 503 still goes through the retry logic
//

/***************************************************************************************************************
	What's up with this queueing code?

	First, a bit of background:

	Media on a prim was added into the system in the Viewer 2.0 timeframe.  In order to avoid changing the 
	network format of objects, an unused field in the object (the "MediaURL" string) was repurposed to 
	indicate that the object had media data, and also hold a sequence number and the UUID of the agent 
	who last updated the data.  The actual media data for objects is accessed via the "ObjectMedia" capability.  
	Due to concerns about sim performance, requests to this capability are rate-limited to 5 requests every 
	5 seconds per agent.

	The initial implementation of LLMediaDataClient used a single queue to manage requests to the "ObjectMedia" cap.  
	Requests to the cap were queued so that objects closer to the avatar were loaded in first, since they were most 
	likely to be the ones the media performance manager would load.

	This worked in some cases, but we found that it was possible for a scripted object that constantly updated its 
	media data to starve other objects, since the same queue contained both requests to load previously unseen media 
	data and requests to fetch media data in response to object updates.

	The solution for this we came up with was to have two queues.  The sorted queue contains requests to fetch media 
	data for objects that don't have it yet, and the round-robin queue contains requests to update media data for 
	objects that have already completed their initial load.  When both queues are non-empty, the code ping-pongs 
	between them so that updates can't completely block initial load-in.
**************************************************************************************************************/

//
// Forward decls
//
const F32 LLMediaDataClient::QUEUE_TIMER_DELAY = 1.0; // seconds(s)
const F32 LLMediaDataClient::UNAVAILABLE_RETRY_TIMER_DELAY = 5.0; // secs
const U32 LLMediaDataClient::MAX_RETRIES = 4;
const U32 LLMediaDataClient::MAX_SORTED_QUEUE_SIZE = 10000;
const U32 LLMediaDataClient::MAX_ROUND_ROBIN_QUEUE_SIZE = 10000;

// << operators
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>
static typename T::iterator find_matching_request(T &c, const LLMediaDataClient::Request *request, LLMediaDataClient::Request::Type match_type)
{
	for(typename T::iterator iter = c.begin(); iter != c.end(); ++iter)
	{
		if(request->isMatch(*iter, match_type))
		{
			return iter;
		}
	}
	
	return c.end();
}

template <typename T>
static typename T::iterator find_matching_request(T &c, const LLUUID &id, LLMediaDataClient::Request::Type match_type)
{
	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();
}

// 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>
static void remove_matching_requests(T &c, const LLUUID &id, LLMediaDataClient::Request::Type match_type)
{
	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;
	}
}

//////////////////////////////////////////////////////////////////////////////////////
//
// LLMediaDataClient
//
//////////////////////////////////////////////////////////////////////////////////////

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()
{
	stopQueueTimer();
}

bool LLMediaDataClient::isEmpty() const
{
	return mQueue.empty();
}

bool LLMediaDataClient::isInQueue(const LLMediaDataClientObject::ptr_t &object)
{
	if(find_matching_request(mQueue, object->getID()) != mQueue.end())
		return true;
	
	if(find_matching_request(mUnQueuedRequests, object->getID()) != 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());
	remove_matching_requests(mUnQueuedRequests, object->getID());
}

void LLMediaDataClient::startQueueTimer() 
{
	if (! mQueueTimerIsRunning)
	{
		LL_DEBUGS("LLMediaDataClient") << "starting queue timer (delay=" << mQueueTimerDelay << " seconds)" << LL_ENDL;
		// LLEventTimer automagically takes care of the lifetime of this object
		new QueueTimer(mQueueTimerDelay, this);
	}
	else { 
		LL_DEBUGS("LLMediaDataClient") << "queue timer is already running" << LL_ENDL;
	}
}

void LLMediaDataClient::stopQueueTimer()
{
	mQueueTimerIsRunning = false;
}

bool LLMediaDataClient::processQueueTimer()
{
	if(isEmpty())
		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();
	
	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();
}

LLMediaDataClient::request_ptr_t LLMediaDataClient::dequeue()
{
	request_ptr_t request;
	request_queue_t *queue_p = getQueue();
	
	if (queue_p->empty())
	{
		LL_DEBUGS("LLMediaDataClient") << "queue empty: " << (*queue_p) << LL_ENDL;
	}
	else
	{
		request = queue_p->front();
		
		if(canServiceRequest(request))
		{
			// We will be returning this request, so remove it from the queue.
			queue_p->pop_front();
		}
		else
		{
			// Don't return this request -- it's not ready to be serviced.
			request = NULL;
		}
	}

	return 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)
{
	request_set_t::iterator iter = mUnQueuedRequests.lower_bound(request);
	
	if (iter != mUnQueuedRequests.end())
	{
		if(*iter == request)
		{
			LL_WARNS("LLMediaDataClient") << "Tracking already tracked request: " << *request << LL_ENDL;
		}
		else
		{
			mUnQueuedRequests.insert(iter, request);
		}
	}
}

void LLMediaDataClient::stopTrackingRequest(request_ptr_t request)
{
	request_set_t::iterator iter = mUnQueuedRequests.find(request);
	
	if (iter != mUnQueuedRequests.end())
	{
		if(*iter == request)
		{
			mUnQueuedRequests.erase(iter);
		}
		else
		{
			LL_WARNS("LLMediaDataClient") << "Removing an untracked request: " << *request << LL_ENDL;
		}
	}
}

void LLMediaDataClient::serviceQueue()
{	
	// Peel one off of the items from the queue and execute it
	request_ptr_t request;
	
	do
	{
		request = dequeue();

		if(request.isNull())
		{
			// Queue is empty.
			return;
		}

		if(request->isDead())
		{
			LL_INFOS("LLMediaDataClient") << "Skipping dead request " << *request << LL_ENDL;
			continue;
		}

	} while(false);
		
	// try to send the HTTP message to the cap url
	std::string url = request->getCapability();
	if (!url.empty())
	{
		const LLSD &sd_payload = request->getPayload();
		LL_INFOS("LLMediaDataClient") << "Sending request for " << *request << LL_ENDL;
		
		// Add this request to the non-queued tracking list
		trackRequest(request);
		
		// and make the post
		LLHTTPClient::post(url, sd_payload, request->createResponder());
	}
	else 
	{
		// Cap url doesn't exist.
		
		if(request->getRetryCount() < mMaxNumRetries)
		{
			LL_WARNS("LLMediaDataClient") << "Could not send request " << *request << " (empty cap url), will retry." << LL_ENDL; 
			// Put this request back at the head of its queue, and retry next time the queue timer fires.
			request->incRetryCount();
			pushBack(request);
		}
		else
		{
			// This request has exceeded its maxumim retry count.  It will be dropped.
			LL_WARNS("LLMediaDataClient") << "Could not send request " << *request << " for " << mMaxNumRetries << " tries, dropping request." << LL_ENDL; 
		}

	}
}


// dump the queue
std::ostream& operator<<(std::ostream &s, const LLMediaDataClient::request_queue_t &q)
{
	int i = 0;
	LLMediaDataClient::request_queue_t::const_iterator iter = q.begin();
	LLMediaDataClient::request_queue_t::const_iterator end = q.end();
	while (iter != end)
	{
		s << "\t" << i << "]: " << (*iter)->getID().asString() << "(" << (*iter)->getObject()->getMediaInterest() << ")";
		iter++;
		i++;
	}
	return s;
}

//////////////////////////////////////////////////////////////////////////////////////
//
// LLMediaDataClient::QueueTimer
// Queue of LLMediaDataClientObject smart pointers to request media for.
//
//////////////////////////////////////////////////////////////////////////////////////

LLMediaDataClient::QueueTimer::QueueTimer(F32 time, LLMediaDataClient *mdc)
: LLEventTimer(time), mMDC(mdc)
{
	mMDC->setIsRunning(true);
}

// virtual
BOOL LLMediaDataClient::QueueTimer::tick()
{
	BOOL result = TRUE;
	
	if (!mMDC.isNull())
	{
		result = mMDC->processQueueTimer();
	
		if(result)
		{
			// This timer won't fire again.  
			mMDC->setIsRunning(false);
			mMDC = NULL;
		}
	}

	return result;
}


//////////////////////////////////////////////////////////////////////////////////////
//
// LLMediaDataClient::Responder::RetryTimer
//
//////////////////////////////////////////////////////////////////////////////////////

LLMediaDataClient::RetryTimer::RetryTimer(F32 time, request_ptr_t request)
: LLEventTimer(time), mRequest(request)
{
	mRequest->startTracking();
}

// virtual
BOOL LLMediaDataClient::RetryTimer::tick()
{
	mRequest->stopTracking();

	if(mRequest->isDead())
	{
		LL_INFOS("LLMediaDataClient") << "RetryTimer fired for dead request: " << *mRequest << ", aborting." << LL_ENDL;
	}
	else
	{
		LL_INFOS("LLMediaDataClient") << "RetryTimer fired for: " << *mRequest << ", retrying." << LL_ENDL;
		mRequest->reEnqueue();
	}
	
	// Release the ref to the request.
	mRequest = NULL;

	// Don't fire again
	return TRUE;
}


//////////////////////////////////////////////////////////////////////////////////////
//
// LLMediaDataClient::Request
//
//////////////////////////////////////////////////////////////////////////////////////
/*static*/U32 LLMediaDataClient::Request::sNum = 0;

LLMediaDataClient::Request::Request(Type in_type,
									LLMediaDataClientObject *obj, 
									LLMediaDataClient *mdc,
									S32 face)
: mType(in_type),
  mObject(obj),
  mNum(++sNum), 
  mRetryCount(0),
  mMDC(mdc),
  mScore((F64)0.0),
  mFace(face)
{
	mObjectID = mObject->getID();
}

const char *LLMediaDataClient::Request::getCapName() const
{
	if(mMDC)
		return mMDC->getCapabilityName();
	
	return "";
}

std::string LLMediaDataClient::Request::getCapability() const
{
	if(mMDC)
	{
		return getObject()->getCapabilityUrl(getCapName());
	}
	
	return "";
}

const char *LLMediaDataClient::Request::getTypeAsString() const
{
	Type t = getType();
	switch (t)
	{
		case GET:
			return "GET";
			break;
		case UPDATE:
			return "UPDATE";
			break;
		case NAVIGATE:
			return "NAVIGATE";
			break;
		case ANY:
			return "ANY";
			break;
	}
	return "";
}


void LLMediaDataClient::Request::reEnqueue()
{
	if(mMDC)
	{
		mMDC->enqueue(this);
	}
}

F32 LLMediaDataClient::Request::getRetryTimerDelay() const
{
	if(mMDC)
		return mMDC->mRetryTimerDelay; 
		
	return 0.0f;
}

U32 LLMediaDataClient::Request::getMaxNumRetries() const
{
	if(mMDC)
		return mMDC->mMaxNumRetries;
	
	return 0;
}

void LLMediaDataClient::Request::updateScore()
{				
	F64 tmp = mObject->getMediaInterest();
	if (tmp != mScore)
	{
		LL_DEBUGS("LLMediaDataClient") << "Score for " << mObject->getID() << " changed from " << mScore << " to " << tmp << LL_ENDL; 
		mScore = tmp;
	}
}
		   
void LLMediaDataClient::Request::markDead() 
{ 
	mMDC = NULL;
}

bool LLMediaDataClient::Request::isDead() 
{ 
	return ((mMDC == NULL) || mObject->isDead()); 
}

void LLMediaDataClient::Request::startTracking() 
{ 
	if(mMDC) 
		mMDC->trackRequest(this); 
}

void LLMediaDataClient::Request::stopTracking() 
{ 
	if(mMDC) 
		mMDC->stopTrackingRequest(this); 
}

std::ostream& operator<<(std::ostream &s, const LLMediaDataClient::Request &r)
{
	s << "request: num=" << r.getNum() 
	<< " type=" << r.getTypeAsString() 
	<< " ID=" << r.getID() 
	<< " face=" << r.getFace() 
	<< " #retries=" << r.getRetryCount();
	return s;
}
			
//////////////////////////////////////////////////////////////////////////////////////
//
// LLMediaDataClient::Responder
//
//////////////////////////////////////////////////////////////////////////////////////

LLMediaDataClient::Responder::Responder(const request_ptr_t &request)
: mRequest(request)
{
}

/*virtual*/
void LLMediaDataClient::Responder::error(U32 status, const std::string& reason)
{
	mRequest->stopTracking();

	if(mRequest->isDead())
	{
		LL_WARNS("LLMediaDataClient") << "dead request " << *mRequest << LL_ENDL;
		return;
	}
	
	if (status == HTTP_SERVICE_UNAVAILABLE)
	{
		F32 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;
		}
	}
	else 
	{
		std::string msg = boost::lexical_cast<std::string>(status) + ": " + reason;
		LL_WARNS("LLMediaDataClient") << *mRequest << " http error(" << msg << ")" << LL_ENDL;
	}
}

/*virtual*/
void LLMediaDataClient::Responder::result(const LLSD& content)
{
	mRequest->stopTracking();

	if(mRequest->isDead())
	{
		LL_WARNS("LLMediaDataClient") << "dead request " << *mRequest << LL_ENDL;
		return;
	}

	LL_DEBUGS("LLMediaDataClientResponse") << *mRequest << " result : " << ll_print_sd(content) << LL_ENDL;
}

//////////////////////////////////////////////////////////////////////////////////////
//
// LLObjectMediaDataClient
// Subclass of LLMediaDataClient for the ObjectMedia cap
//
//////////////////////////////////////////////////////////////////////////////////////

void LLObjectMediaDataClient::fetchMedia(LLMediaDataClientObject *object)
{
	// Create a get request and put it in the queue.
	enqueue(new RequestGet(object, this));
}

const char *LLObjectMediaDataClient::getCapabilityName() const 
{
	return "ObjectMedia";
}

LLObjectMediaDataClient::request_queue_t *LLObjectMediaDataClient::getQueue()
{
	return (mCurrentQueueIsTheSortedQueue) ? &mQueue : &mRoundRobinQueue;
}

void LLObjectMediaDataClient::sortQueue()
{
	if(!mQueue.empty())
	{
		// score all elements in the sorted queue.
		for(request_queue_t::iterator iter = mQueue.begin(); iter != mQueue.end(); iter++)
		{
			(*iter)->updateScore();
		}
		
		// Re-sort the list...
		mQueue.sort(compareRequestScores);
		
		// ...then cull items over the max
		U32 size = mQueue.size();
		if (size > mMaxSortedQueueSize) 
		{
			U32 num_to_cull = (size - mMaxSortedQueueSize);
			LL_INFOS_ONCE("LLMediaDataClient") << "sorted queue MAXED OUT!  Culling " 
				<< num_to_cull << " items" << LL_ENDL;
			while (num_to_cull-- > 0)
			{
				mQueue.back()->markDead();
				mQueue.pop_back();
			}
		}
	}
	
}

// static
bool LLObjectMediaDataClient::compareRequestScores(const request_ptr_t &o1, const request_ptr_t &o2)
{
	if (o2.isNull()) return true;
	if (o1.isNull()) return false;
	return ( o1->getScore() > o2->getScore() );
}

void LLObjectMediaDataClient::enqueue(Request *request)
{
	if(request->isDead())
	{
		LL_DEBUGS("LLMediaDataClient") << "not queueing dead request " << *request << LL_ENDL;
		return;
	}

	// Invariants:
	// new requests always go into the sorted queue.
	//  
	
	bool is_new = request->isNew();
	
	if(!is_new && (request->getType() == Request::GET))
	{
		// 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);
		
		if( (iter != mRoundRobinQueue.end()) || (iter2 != mUnQueuedRequests.end()) )
		{
			LL_DEBUGS("LLMediaDataClient") << "ALREADY THERE: NOT Queuing request for " << *request << LL_ENDL;

			return;
		}
	}
	
	// TODO: should an UPDATE cause pending GET requests for the same object to be removed from the queue?
	// 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());

	if (is_new)
	{
		LL_DEBUGS("LLMediaDataClient") << "Queuing SORTED request for " << *request << LL_ENDL;
		
		mQueue.push_back(request);
		
		LL_DEBUGS("LLMediaDataClientQueue") << "SORTED queue:" << mQueue << LL_ENDL;
	}
	else
	{
		if (mRoundRobinQueue.size() > mMaxRoundRobinQueueSize) 
		{
			LL_INFOS_ONCE("LLMediaDataClient") << "RR QUEUE MAXED OUT!!!" << LL_ENDL;
			LL_DEBUGS("LLMediaDataClient") << "Not queuing " << *request << LL_ENDL;
			return;
		}
				
		LL_DEBUGS("LLMediaDataClient") << "Queuing RR request for " << *request << LL_ENDL;
		// Push the request on the pending queue
		mRoundRobinQueue.push_back(request);
		
		LL_DEBUGS("LLMediaDataClientQueue") << "RR queue:" << mRoundRobinQueue << LL_ENDL;			
	}	
	// Start the timer if not already running
	startQueueTimer();
}

bool LLObjectMediaDataClient::canServiceRequest(request_ptr_t request) 
{
	if(mCurrentQueueIsTheSortedQueue)
	{
		if(!request->getObject()->isInterestingEnough())
		{
			LL_DEBUGS("LLMediaDataClient") << "Not fetching " << *request << ": not interesting enough" << LL_ENDL;
			return false;
		}
	}
	
	return true; 
};

void LLObjectMediaDataClient::swapCurrentQueue()
{
	// Swap
	mCurrentQueueIsTheSortedQueue = !mCurrentQueueIsTheSortedQueue;
	// If its empty, swap back
	if (getQueue()->empty()) 
	{
		mCurrentQueueIsTheSortedQueue = !mCurrentQueueIsTheSortedQueue;
	}
}

bool LLObjectMediaDataClient::isEmpty() const
{
	return mQueue.empty() && mRoundRobinQueue.empty();
}

bool LLObjectMediaDataClient::isInQueue(const LLMediaDataClientObject::ptr_t &object)
{
	// First, call parent impl.
	if(LLMediaDataClient::isInQueue(object))
		return true;

	if(find_matching_request(mRoundRobinQueue, object->getID()) != mRoundRobinQueue.end())
		return true;
	
	return false;
}

void LLObjectMediaDataClient::removeFromQueue(const LLMediaDataClientObject::ptr_t &object)
{
	// First, call parent impl.
	LLMediaDataClient::removeFromQueue(object);
	
	remove_matching_requests(mRoundRobinQueue, object->getID());
}

bool LLObjectMediaDataClient::processQueueTimer()
{
	if(isEmpty())
		return true;
		
	LL_DEBUGS("LLMediaDataClient") << "started, SORTED queue size is:	  " << mQueue.size() 
		<< ", RR queue size is:	  " << mRoundRobinQueue.size() << LL_ENDL;
	LL_DEBUGS("LLMediaDataClientQueue") << "    SORTED queue is:	  " << mQueue << LL_ENDL;
	LL_DEBUGS("LLMediaDataClientQueue") << "    RR queue is:	  " << mRoundRobinQueue << LL_ENDL;

//	purgeDeadRequests();

	sortQueue();

	LL_DEBUGS("LLMediaDataClientQueue") << "after sort, SORTED queue is:	  " << mQueue << LL_ENDL;
	
	serviceQueue();

	swapCurrentQueue();
	
	LL_DEBUGS("LLMediaDataClient") << "finished, SORTED queue size is:	  " << mQueue.size() 
		<< ", RR queue size is:	  " << mRoundRobinQueue.size() << LL_ENDL;
	LL_DEBUGS("LLMediaDataClientQueue") << "    SORTED queue is:	  " << mQueue << LL_ENDL;
	LL_DEBUGS("LLMediaDataClientQueue") << "    RR queue is:	  " << mRoundRobinQueue << LL_ENDL;
	
	return isEmpty();
}

LLObjectMediaDataClient::RequestGet::RequestGet(LLMediaDataClientObject *obj, LLMediaDataClient *mdc):
	LLMediaDataClient::Request(LLMediaDataClient::Request::GET, obj, mdc)
{
}

LLSD LLObjectMediaDataClient::RequestGet::getPayload() const
{
	LLSD result;
	result["verb"] = "GET";
	result[LLTextureEntry::OBJECT_ID_KEY] = mObject->getID();
	
	return result;
}

LLMediaDataClient::Responder *LLObjectMediaDataClient::RequestGet::createResponder()
{
	return new LLObjectMediaDataClient::Responder(this);
}


void LLObjectMediaDataClient::updateMedia(LLMediaDataClientObject *object)
{
	// Create an update request and put it in the queue.
	enqueue(new RequestUpdate(object, this));
}

LLObjectMediaDataClient::RequestUpdate::RequestUpdate(LLMediaDataClientObject *obj, LLMediaDataClient *mdc):
	LLMediaDataClient::Request(LLMediaDataClient::Request::UPDATE, obj, mdc)
{
}

LLSD LLObjectMediaDataClient::RequestUpdate::getPayload() const
{
	LLSD result;
	result["verb"] = "UPDATE";
	result[LLTextureEntry::OBJECT_ID_KEY] = mObject->getID();

	LLSD object_media_data;
	int i = 0;
	int end = mObject->getMediaDataCount();
	for ( ; i < end ; ++i) 
	{
		object_media_data.append(mObject->getMediaDataLLSD(i));
	}
	
	result[LLTextureEntry::OBJECT_MEDIA_DATA_KEY] = object_media_data;
	
	return result;
}

LLMediaDataClient::Responder *LLObjectMediaDataClient::RequestUpdate::createResponder()
{
	// This just uses the base class's responder.
	return new LLMediaDataClient::Responder(this);
}


/*virtual*/
void LLObjectMediaDataClient::Responder::result(const LLSD& content)
{
	getRequest()->stopTracking();

	if(getRequest()->isDead())
	{
		LL_WARNS("LLMediaDataClient") << "dead request " << *(getRequest()) << LL_ENDL;
		return;
	}

	// This responder is only used for GET requests, not UPDATE.

	LL_DEBUGS("LLMediaDataClientResponse") << *(getRequest()) << " GET returned: " << ll_print_sd(content) << 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
// Subclass of LLMediaDataClient for the ObjectMediaNavigate cap
//
//////////////////////////////////////////////////////////////////////////////////////

const char *LLObjectMediaNavigateClient::getCapabilityName() const 
{
	return "ObjectMediaNavigate";
}

void LLObjectMediaNavigateClient::enqueue(Request *request)
{
	if(request->isDead())
	{
		LL_DEBUGS("LLMediaDataClient") << "not queueing dead request " << *request << LL_ENDL;
		return;
	}
	
	// If there's already a matching request in the queue, remove it.
	request_queue_t::iterator iter = find_matching_request(mQueue, request);
	if(iter != mQueue.end())
	{
		LL_DEBUGS("LLMediaDataClient") << "removing matching queued request " << (**iter) << LL_ENDL;
		mQueue.erase(iter);
	}
	else
	{
		request_set_t::iterator set_iter = find_matching_request(mUnQueuedRequests, request);
		if(set_iter != mUnQueuedRequests.end())
		{
			LL_DEBUGS("LLMediaDataClient") << "removing matching unqueued request " << (**set_iter) << LL_ENDL;
			mUnQueuedRequests.erase(set_iter);
		}
	}

#if 0
	// Sadly, this doesn't work.  It ends up creating a race condition when the user navigates and then hits the "back" button
	// where the navigate-back appears to be spurious and doesn't get broadcast.	
	if(request->getObject()->isCurrentMediaUrl(request->getFace(), request->getURL()))
	{
		// This navigate request is trying to send the face to the current URL.  Drop it.
		LL_DEBUGS("LLMediaDataClient") << "dropping spurious request " << (*request) << LL_ENDL;
	}
	else
#endif
	{
		LL_DEBUGS("LLMediaDataClient") << "queueing new request " << (*request) << LL_ENDL;
		mQueue.push_back(request);
		
		// Start the timer if not already running
		startQueueTimer();
	}
}

void LLObjectMediaNavigateClient::navigate(LLMediaDataClientObject *object, U8 texture_index, const std::string &url)
{

//	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));
}

LLObjectMediaNavigateClient::RequestNavigate::RequestNavigate(LLMediaDataClientObject *obj, LLMediaDataClient *mdc, U8 texture_index, const std::string &url):
	LLMediaDataClient::Request(LLMediaDataClient::Request::NAVIGATE, obj, mdc, (S32)texture_index),
	mURL(url)
{
}

LLSD LLObjectMediaNavigateClient::RequestNavigate::getPayload() const
{
	LLSD result;
	result[LLTextureEntry::OBJECT_ID_KEY] = getID();
	result[LLMediaEntry::CURRENT_URL_KEY] = mURL;
	result[LLTextureEntry::TEXTURE_INDEX_KEY] = (LLSD::Integer)getFace();
	
	return result;
}

LLMediaDataClient::Responder *LLObjectMediaNavigateClient::RequestNavigate::createResponder()
{
	return new LLObjectMediaNavigateClient::Responder(this);
}

/*virtual*/
void LLObjectMediaNavigateClient::Responder::error(U32 status, const std::string& reason)
{
	getRequest()->stopTracking();

	if(getRequest()->isDead())
	{
		LL_WARNS("LLMediaDataClient") << "dead request " << *(getRequest()) << LL_ENDL;
		return;
	}

	// Bounce back (unless HTTP_SERVICE_UNAVAILABLE, in which case call base
	// class
	if (status == HTTP_SERVICE_UNAVAILABLE)
	{
		LLMediaDataClient::Responder::error(status, reason);
	}
	else
	{
		// bounce the face back
		LL_WARNS("LLMediaDataClient") << *(getRequest()) << " Error navigating: http code=" << status << 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::result(const LLSD& content)
{
	getRequest()->stopTracking();

	if(getRequest()->isDead())
	{
		LL_WARNS("LLMediaDataClient") << "dead request " << *(getRequest()) << LL_ENDL;
		return;
	}

	LL_INFOS("LLMediaDataClient") << *(getRequest()) << " NAVIGATE returned " << ll_print_sd(content) << LL_ENDL;
	
	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;
		}			 

		// XXX Warn user?
	}
	else 
	{
		// No action required.
		LL_DEBUGS("LLMediaDataClientResponse") << *(getRequest()) << " result : " << ll_print_sd(content) << LL_ENDL;
	}
}