summaryrefslogtreecommitdiff
path: root/indra/newview/llmediadataclient.cpp
AgeCommit message (Collapse)Author
2013-04-19merge changes for DRTVWR-294Oz Linden
2013-03-29Update Mac and Windows breakpad builds to latestGraham Madarasz
2013-03-05Fixing issues with not detecting when LLSD XML parsing fails. Changing most ↵Don Kjer
http error handlers to understand LLSD error responses. Fleshing out most http error handler message spam.
2010-08-24Backed out changeset c3d41f18ce2bTofu Linden
back-out the back-out for this branch. yay.
2010-08-24Backed out changeset a62bf7c0af21Tofu Linden
Backing out this merge that I pushed (prematurely) to the wrong place.
2010-08-24merge heads. whew.Tofu Linden
2010-08-13Change license from GPL to LGPL (version 2.1)Oz Linden
2010-08-09Patch on a fix for the llmediadataclient.cpp unit test.Monroe Linden
My refactor of LLMediaDataClient caused a crash in the windows unit test. Change set 92fd90bd795a fixed the crash, but broke the code in question. This changeset should make the code behave correctly, while removing some premature optimization that I now think didn't properly in the first place.
2010-08-03fix for unit test assertsRichard Linden
2010-07-30fixed windows buildRichard Nelson
2010-07-29Yet more cleanup around llmediadataclient.Monroe Linden
In LLVOVolume, added a count of LLMediaDataClientObjectImpl objects referencing each LLVOVolume object. This allows LLVOVolume::markDead() to skip the relatively expensive calls to removeFromQueue() when the LLVOVolume is known to have no active references. Refactored LLMediaDataClient and its two child classes so that only LLObjectMediaDataClient has the round-robin queue (LLObjectMediaNavigateClient doesn't need it), and cleaned up some of the virtual function hierarchy around queue processing. In LLMediaDataClient, added tracking for requests that aren't currently in a queue (i.e. requests that are in flight or waiting for retries) so they can be found when their objects are marked dead. LLMediaDataClient::Request now directly keeps track of the object ID and face associated with the request. Removed the "markedSent" concept from requests. Requests that have been sent are no longer kept in a queue. The Retry timer now references the Request object instead of the Responder. Replaced LLMediaDataClient::findOrRemove() with separate template functions for find and remove.
2010-07-23More cleanup around llmediadataclient.Monroe Linden
LLMediaDataClient::Request no longer stores the LLSD payload -- it now uses the link to the LLVOVolume (which it was already keeping around) to generate the LLSD for the request at the time it's sent. LLMediaDataClient::Request no longer stores a capability name. Instead it uses the reference to its parent LLMediaDataClient subclass to refer to it as needed. LLMediaDataClient::Request is now a base class, with subclasses for each specific request type -- GET, UPDATE, and NAVIGATE. Responders are now created by a virtual method in the LLMediaDataClient::Request subclass instead of being created by the MDC. This allows different request types to use different responder classes. Fixed an issue with LLMediaDataClient::QueueTimer and LLMediaDataClient::RetryTimer that caused the unit test to fail (they now do all the work in their tick() functions instead of using the destructor).
2010-07-21Miscellaneous cleanup in and around llmediadataclient.Monroe Linden
Added tags to some media-related logging in LLVOVolume. Made LLMediaDataClient::Responder do most of its work in tick() instead of its destructor. Added a comment to llmediadataclient.cpp that explains the idea behind the two-queue system. Made LLMediaDataClient::sortQueue() remove requests from the queue that hold references to dead items. This should make teleporting away solve many of the pathological queueing cases. Updated llmediadataclient test cases to reflect the change in behavior in sortQueue(). Removed some unnecessary const-ness in LLMediaDataClient::enqueue, which caused it to have to use const_cast.
2009-12-18Slight hack: if pixel area is 1024, force recalculation of itRick Pasetto
This is because I've observed that in heavy regions, media was not getting loaded because the queue items were stuck with the head item at interest = 1024. This is the "default" value, which means it probably wasn't calculated yet. This forces the calculation. Also cleaned up some logging in mediadataclient
2009-12-16Dial down logging in mediadataclientRick Pasetto
2009-12-14Allow selection of media faces even if there is no impl. We recordRick Pasetto
the target object and use that fact to raise its interest level. This is mostly a pass-off for monroe to take and run with
2009-12-11Fix linux buildRick Pasetto
2009-12-10PARTIAL DEV-43869 - add "isInterestingEnough()" to the queue calculationRick Pasetto
This change bumps the queue sizes way up, because we think that the "isInterestingEnough()" call will prevent loading more media data than we think is necessary. Still need to implement it in LLVOVolume, though
2009-12-10PARTIAL DEV-43869: LLMediaDataClient now uses two queuesRick Pasetto
This is a fairly major change that addresses the issue of an object with constantly-updating media. Before, that object would be put into our single queue and sorted to a particular spot, and since it continuously updates, it would "always be there". That means that nothing "behind" it would ever get serviced. This change introduces two queues for each MDC: one is the same "sorted" queue as before, and the other is unsorted, and "round-robins". New objects go into the sorted queue, objects whose media we already know about get put into the unsorted queue. The two queues are interleaved when serviced (one then the other is serviced -- if one is empty we try the other -- until they are both drained). The round-robin queue works a little differently: after an item is fetched from that queue (remember this would be an item we already know about), that request is marked and put back at the end of the queue. If that object gets a UDP update while in the queue, that mark is "cleared". When it gets to the front of the queue again, if it still marked, it is thrown away. If it is not marked, it is fetched, and again marked and put at the end. This makes the queue self-limiting in how big it can get. I have also made some other changes: - The sorting comparator now just delegates to the object for its "interest" calculation. A higher value = more interesting. LLVOVolume now uses its PixelArea for its "interest" calculation, which seems apparently better (the prior distance calculation was wrong anyway). - The score is cached before the sort operation is performed, so that it won't be expensive to sort - Now, the media version that is fetched is saved in the LLVOVolume, and we do not update if it is not newer (this is not very useful...yet.) - I've introduced hard limits (settable by debug settings) on the size of the queues. The sorted queue will be culled (after sort) to that count. NOTE: this will probably get removed in a later checkin, as I've already gotten feedback that this is not desirable - I've reorganized LLMediaDataClient so it makes more sense. - I've made the request object a little smaller, so the queue won't take up so much memory (more work could be done here) - Added a unit test for the two-queue case (though more tests are needed!)
2009-11-24Code review feedback:Rick Pasetto
Don't re-sort when adding to the queue: it isn't really necessary since we sort every time we pull off the queue.
2009-11-24DEV-41998 - refactor mediadataclient to use a std::list, and re-sort every ↵Rick Pasetto
time an item is pulled off the queue Review #43 This change refactors mediadataclient to no longer use a PriorityQueue (which sorts only on insertion), but rather just use a std::list which is re-sorted on insert, and also when "popped" (at the time the queue timer goes off). Also implemented a unit test to make sure re-sorting occurs on timer tick.
2009-11-20Clean up some loggingRick Pasetto
2009-11-19Made LLMediaDataClient not send requests on behalf of objects that are ↵Monroe Linden
marked as dead. When LLMediaDataClient::QueueTimer::tick() encounters an object at the head of the queue that's dead, it will now remove that object and loop, instead of sending a request and waiting for the tick timer to fire again. Added an isDead() function to LLMediaDataClientObject, and an additional unit test that verifies the handling of dead objects.
2009-11-10FIX DEV-41991: do not allow media settings panel to come up if media data is ↵Rick Pasetto
in flight Review #33 This change marks the current selection "not editable" if any objects in the selection are currently "in flight" (i.e. their media data has not been fetched yet, or is in the process of being fetched). This involved adding API to LLMediaDataClient to query whether an object is in the process of being fetched (i.e. in the queue). I've added a unit test for this new API.
2009-10-26Add some logging to perhaps discern more information about reported crashesRick Pasetto
2009-10-19Compress logging of media data (but still have it)Rick Pasetto
2009-10-19mergeSteve Bennetts
2009-10-13Another attempt at fixing unit test, this one is weirder.Rick Pasetto
Don't schedule the queue timer in the tick() of the retry timer. Instead, schedule it in the RetryTimer's destructor. This is an artifact of how the LLEventTimer's loop is handled.
2009-10-12Add some more logging to help triage media client problemsRick Pasetto
2009-10-12merge of login-apipalange
2009-10-09Unit tests for LLMediaDataClientRick Pasetto
This required a bit of refactoring of LLMediaDataClient: - Created LLMediaDataClientObject ABC, which now has a concrete impl in LLVOVolume - Created unit test with 6 tests (for now), testing - LLObjectMediaDataClient::fetchMedia() - LLObjectMediaDataClient::updateMedia() - LLObjectMediaNavigateClient::navigate() - queue ordering - retries - nav bounce back - Also ensures that ref counting works properly (this is important, because ownership is tricky with smart pointers put into queues, peeled off into timers that fire and auto destruct, and HTTP responders that also auto-destruct) - Had to fix LLCurl::Responder's stub, which was not initializing the ref count to 0, causing the ref counting tests to fail (boy, that was hard to find!). Reviewed by Callum
2009-10-07Post-merge cleanup to get things building again.brad kittenbrink
2009-10-07DEV-39168 - bounce back to the current URL (or, the home URL if current URL ↵Rick Pasetto
is "") if the server denies navigation This refactors some of the bounceBack code into LLVOVolume. It also changes an important rule: the edit panel now *will* send the current URL to the server when you hit "OK". This change was done so that if autoplay is on, we make sure the server gets the right data.
2009-10-06DEV-40896: Don't iteratively pop() the request queue on destroy(). This ↵Rick Pasetto
just logs now and deletes the queue.
2009-10-05Back out changes accidentally checked in with last commitRick Pasetto
2009-10-05FIX DEV-40877: ignore changes from "bad" objects which have an invalid media URLRick Pasetto
2009-10-05DEV-40853: don't bring up a dialog on HTTP errors in the media serviceRick Pasetto
2009-10-05merge with latest from lindenlab/svn-imports-viewer-20Mark Palange (Mani)
2009-10-05Disable "bounceBack" if nav permissions are refusedRick Pasetto
2009-10-05DEV-40650: Refactor llmediadataresponder and llmediadatafetcher into a ↵Rick Pasetto
single reusable class CC Review #7 (monroe) LLMediaDataResponder and LLMediaDataFetcher were helpful classes that interacted with each other, but they were not general enough to cleanly be used for all media service interaction. This change refactors these classes into one (in fact, it is closer to a complete rewrite): LLMediaDataClient. This class has the following design points: - You subclass from it when you want to specialize the responder, and then subclass from LLMediaDataClient::Responder if desired - It has a few inner classes: - LLMediaDataClient::Request, which now holds all of the data pertaining to a request, including retry counts - LLMediaDataClient::Responder, which is now the LLHTTPClient::Responder - LLMediaDataClient::PriorityQueue, which is now a STL priority_queue of Request objects. - LLMediaDataClient::QueueTimer, which is the timer that fires to peel off queue items - LLMediaDataClient::Responder::RetryTimer, which is the timer that is used when 503 errors are received. The encapsulation of these inner classes is a lot cleaner and better reflects the scope of their responsibilities. By and large, the logic hasn't really changed much. However, now there are two subclasses of LLMediaDataClient: one for the ObjectMedia cap and the other for the ObjectMediaNavigate cap. (I decided it was overkill to make three subclasses, one each for GET, UPDATE, and NAVIGATE, but we could still do that). LLVOVolume now instantiates both of these classes as statics (and destroys them on shutdown). They now have very simple API: - LLObjectMediaDataClient::fetchMedia(LLVOVolume*) fetches the media for the given object - LLObjectMediaDataClient::updateMedia(LLVOVolume*) sends an UPDATE of the media from the given object - LLObjectMediaNavigateClient::navigate(LLVOVolume*, U8 texture_index, const std::string &url) navigates the given face (texture_index) on the given object to the given url.