1 files changed, 308 insertions, 105 deletions

diff --git a/indra/newview/llviewermedia.cpp b/indra/newview/llviewermedia.cpp
index 69650425cb..8c41133a3a 100644
--- a/indra/newview/llviewermedia.cpp
+++ b/indra/newview/llviewermedia.cpp
@@ -32,6 +32,7 @@
 
 #include "llviewerprecompiledheaders.h"
 
+#include "llagent.h"
 #include "llviewermedia.h"
 #include "llviewermediafocus.h"
 #include "llmimetypes.h"
@@ -54,6 +55,8 @@
 #include <boost/bind.hpp>	// for SkinFolder listener
 #include <boost/signals2.hpp>
 
+/*static*/ const char* LLViewerMedia::AUTO_PLAY_MEDIA_SETTING = "AutoPlayMedia";
+
 // Move this to its own file.
 
 LLViewerMediaEventEmitter::~LLViewerMediaEventEmitter()
@@ -135,9 +138,19 @@ public:
 	LLMimeDiscoveryResponder( viewer_media_t media_impl)
 		: mMediaImpl(media_impl),
 		  mInitialized(false)
-	{}
-
+	{
+		if(mMediaImpl->mMimeTypeProbe != NULL)
+		{
+			llerrs << "impl already has an outstanding responder" << llendl;
+		}
+		
+		mMediaImpl->mMimeTypeProbe = this;
+	}
 
+	~LLMimeDiscoveryResponder()
+	{
+		disconnectOwner();
+	}
 
 	virtual void completedHeader(U32 status, const std::string& reason, const LLSD& content)
 	{
@@ -149,23 +162,63 @@ public:
 
 	virtual void error( U32 status, const std::string& reason )
 	{
-		// completeAny(status, "none/none");
+		if(status == 401)
+		{
+			// This is the "you need to authenticate" status.  
+			// Treat this like an html page.
+			completeAny(status, "text/html");
+		}
+		else
+		{
+			llwarns << "responder failed with status " << status << ", reason " << reason << llendl;
+		
+			if(mMediaImpl)
+			{
+				mMediaImpl->mMediaSourceFailed = true;
+			}
+		}
 	}
 
 	void completeAny(U32 status, const std::string& mime_type)
 	{
-		if(!mInitialized && ! mime_type.empty())
+		// the call to initializeMedia may disconnect the responder, which will clear mMediaImpl.
+		// Make a local copy so we can call loadURI() afterwards.
+		LLViewerMediaImpl *impl = mMediaImpl;
+		
+		if(impl && !mInitialized && ! mime_type.empty())
 		{
-			if(mMediaImpl->initializeMedia(mime_type))
+			if(impl->initializeMedia(mime_type))
 			{
 				mInitialized = true;
-				mMediaImpl->loadURI();
+				impl->loadURI();
+				disconnectOwner();
 			}
 		}
 	}
+	
+	void cancelRequest()
+	{
+		disconnectOwner();
+	}
+	
+private:
+	void disconnectOwner()
+	{
+		if(mMediaImpl)
+		{
+			if(mMediaImpl->mMimeTypeProbe != this)
+			{
+				llerrs << "internal error: mMediaImpl->mMimeTypeProbe != this" << llendl;
+			}
 
-	public:
-		viewer_media_t mMediaImpl;
+			mMediaImpl->mMimeTypeProbe = NULL;
+		}
+		mMediaImpl = NULL;
+	}
+	
+	
+public:
+		LLViewerMediaImpl *mMediaImpl;
 		bool mInitialized;
 };
 static LLViewerMedia::impl_list sViewerMediaImplList;
@@ -225,7 +278,7 @@ viewer_media_t LLViewerMedia::newMediaImpl(
 	}
 	else
 	{
-		media_impl->stop();
+		media_impl->unload();
 		media_impl->mTextureId = texture_id;
 		media_impl->mMediaWidth = media_width;
 		media_impl->mMediaHeight = media_height;
@@ -240,7 +293,12 @@ viewer_media_t LLViewerMedia::updateMediaImpl(LLMediaEntry* media_entry, const s
 {	
 	// Try to find media with the same media ID
 	viewer_media_t media_impl = getMediaImplFromTextureID(media_entry->getMediaID());
-
+	
+	lldebugs << "called, current URL is \"" << media_entry->getCurrentURL() 
+			<< "\", previous URL is \"" << previous_url 
+			<< "\", update_from_self is " << (update_from_self?"true":"false")
+			<< llendl;
+			
 	bool was_loaded = false;
 	bool needs_navigate = false;
 	
@@ -261,21 +319,32 @@ viewer_media_t LLViewerMedia::updateMediaImpl(LLMediaEntry* media_entry, const s
 			media_impl->mMediaSource->setSize(media_entry->getWidthPixels(), media_entry->getHeightPixels());
 		}
 		
+		bool url_changed = (media_entry->getCurrentURL() != previous_url);
 		if(media_entry->getCurrentURL().empty())
 		{
-			// The current media URL is now empty.  Unload the media source.
-			media_impl->unload();
+			if(url_changed)
+			{
+				// The current media URL is now empty.  Unload the media source.
+				media_impl->unload();
+			
+				lldebugs << "Unloading media instance (new current URL is empty)." << llendl;
+			}
 		}
 		else
 		{
 			// The current media URL is not empty.
 			// If (the media was already loaded OR the media was set to autoplay) AND this update didn't come from this agent,
 			// do a navigate.
+			bool auto_play = (media_entry->getAutoPlay() && gSavedSettings.getBOOL(AUTO_PLAY_MEDIA_SETTING));
 			
-			if((was_loaded || (media_entry->getAutoPlay() && gSavedSettings.getBOOL("AutoPlayMedia"))) && !update_from_self)
+			if((was_loaded || auto_play) && !update_from_self)
 			{
-				needs_navigate = (media_entry->getCurrentURL() != previous_url);
+				needs_navigate = url_changed;
 			}
+			
+			lldebugs << "was_loaded is " << (was_loaded?"true":"false") 
+					<< ", auto_play is " << (auto_play?"true":"false") 
+					<< ", needs_navigate is " << (needs_navigate?"true":"false") << llendl;
 		}
 	}
 	else
@@ -289,17 +358,30 @@ viewer_media_t LLViewerMedia::updateMediaImpl(LLMediaEntry* media_entry, const s
 		
 		media_impl->setHomeURL(media_entry->getHomeURL());
 		
-		if(media_entry->getAutoPlay() && gSavedSettings.getBOOL("AutoPlayMedia"))
+		if(media_entry->getAutoPlay() && gSavedSettings.getBOOL(AUTO_PLAY_MEDIA_SETTING))
 		{
 			needs_navigate = true;
 		}
 	}
 	
-	if(media_impl && needs_navigate)
+	if(media_impl)
 	{
 		std::string url = media_entry->getCurrentURL();
-			
-		media_impl->navigateTo(url, "", true, true);
+		if(needs_navigate)
+		{
+			media_impl->navigateTo(url, "", true, true);
+			lldebugs << "navigating to URL " << url << llendl;
+		}
+		else if(!media_impl->mMediaURL.empty() && (media_impl->mMediaURL != url))
+		{
+			// If we already have a non-empty media URL set and we aren't doing a navigate, update the media URL to match the media entry.
+			media_impl->mMediaURL = url;
+
+			// If this causes a navigate at some point (such as after a reload), it should be considered server-driven so it isn't broadcast.
+			media_impl->mNavigateServerRequest = true;
+
+			lldebugs << "updating URL in the media impl to " << url << llendl;
+		}
 	}
 	
 	return media_impl;
@@ -479,6 +561,16 @@ bool LLViewerMedia::priorityComparitor(const LLViewerMediaImpl* i1, const LLView
 		// The item with user focus always comes to the front of the list, period.
 		return false;
 	}
+	else if(i1->isParcelMedia())
+	{
+		// The parcel media impl sorts above all other inworld media, unless one has focus.
+		return true;
+	}
+	else if(i2->isParcelMedia())
+	{
+		// The parcel media impl sorts above all other inworld media, unless one has focus.
+		return false;
+	}
 	else if(i1->getUsedInUI() && !i2->getUsedInUI())
 	{
 		// i1 is a UI element, i2 is not.  This makes i1 "less than" i2, so it sorts earlier in our list.
@@ -489,16 +581,21 @@ bool LLViewerMedia::priorityComparitor(const LLViewerMediaImpl* i1, const LLView
 		// i2 is a UI element, i1 is not.  This makes i2 "less than" i1, so it sorts earlier in our list.
 		return false;
 	}
-	else if(i1->isParcelMedia())
+	else if(i1->isPlayable() && !i2->isPlayable())
 	{
-		// The parcel media impl sorts above all other inworld media, unless one has focus.
+		// Playable items sort above ones that wouldn't play even if they got high enough priority
 		return true;
 	}
-	else if(i2->isParcelMedia())
+	else if(!i1->isPlayable() && i2->isPlayable())
 	{
-		// The parcel media impl sorts above all other inworld media, unless one has focus.
+		// Playable items sort above ones that wouldn't play even if they got high enough priority
 		return false;
 	}
+	else if(i1->getInterest() == i2->getInterest())
+	{
+		// Generally this will mean both objects have zero interest.  In this case, sort on distance.
+		return (i1->getProximityDistance() < i2->getProximityDistance());
+	}
 	else
 	{
 		// The object with the larger interest value should be earlier in the list, so we reverse the sense of the comparison here.
@@ -506,6 +603,11 @@ bool LLViewerMedia::priorityComparitor(const LLViewerMediaImpl* i1, const LLView
 	}
 }
 
+static bool proximity_comparitor(const LLViewerMediaImpl* i1, const LLViewerMediaImpl* i2)
+{
+	return (i1->getProximityDistance() < i2->getProximityDistance());
+}
+
 //////////////////////////////////////////////////////////////////////////////////////////
 // static
 void LLViewerMedia::updateMedia()
@@ -531,12 +633,9 @@ void LLViewerMedia::updateMedia()
 	int impl_count_total = 0;
 	int impl_count_interest_low = 0;
 	int impl_count_interest_normal = 0;
-	int i = 0;
-
-#if 0	
-	LL_DEBUGS("PluginPriority") << "Sorted impls:" << llendl;
-#endif
-
+	
+	std::vector<LLViewerMediaImpl*> proximity_order;
+	
 	U32 max_instances = gSavedSettings.getU32("PluginInstancesTotal");
 	U32 max_normal = gSavedSettings.getU32("PluginInstancesNormal");
 	U32 max_low = gSavedSettings.getU32("PluginInstancesLow");
@@ -567,10 +666,12 @@ void LLViewerMedia::updateMedia()
 		else if(pimpl->hasFocus())
 		{
 			new_priority = LLPluginClassMedia::PRIORITY_HIGH;
+			impl_count_interest_normal++;	// count this against the count of "normal" instances for priority purposes
 		}
 		else if(pimpl->getUsedInUI())
 		{
 			new_priority = LLPluginClassMedia::PRIORITY_NORMAL;
+			impl_count_interest_normal++;
 		}
 		else
 		{
@@ -578,7 +679,17 @@ void LLViewerMedia::updateMedia()
 			
 			// Heuristic -- if the media texture's approximate screen area is less than 1/4 of the native area of the texture,
 			// turn it down to low instead of normal.  This may downsample for plugins that support it.
-			bool media_is_small = pimpl->getInterest() < (pimpl->getApproximateTextureInterest() / 4);
+			bool media_is_small = false;
+			F64 approximate_interest = pimpl->getApproximateTextureInterest();
+			if(approximate_interest == 0.0f)
+			{
+				// this media has no current size, which probably means it's not loaded.
+				media_is_small = true;
+			}
+			else if(pimpl->getInterest() < (approximate_interest / 4))
+			{
+				media_is_small = true;
+			}
 			
 			if(pimpl->getInterest() == 0.0f)
 			{
@@ -616,7 +727,7 @@ void LLViewerMedia::updateMedia()
 			}
 		}
 		
-		if(new_priority != LLPluginClassMedia::PRIORITY_UNLOADED)
+		if(!pimpl->getUsedInUI() && (new_priority != LLPluginClassMedia::PRIORITY_UNLOADED))
 		{
 			impl_count_total++;
 		}
@@ -630,23 +741,27 @@ void LLViewerMedia::updateMedia()
 		}
 		else
 		{
-			// Other impls just get the same ordering as the priority list (for now).
-			pimpl->mProximity = i;
+			proximity_order.push_back(pimpl);
 		}
 
-#if 0		
-		LL_DEBUGS("PluginPriority") << "    " << pimpl 
-			<< ", setting priority to " << new_priority
-			<< (pimpl->hasFocus()?", HAS FOCUS":"") 
-			<< (pimpl->getUsedInUI()?", is UI":"") 
-			<< ", cpu " << pimpl->getCPUUsage() 
-			<< ", interest " << pimpl->getInterest() 
-			<< ", media url " << pimpl->getMediaURL() << llendl;
-#endif
-
 		total_cpu += pimpl->getCPUUsage();
-		
-		i++;
+	}
+	
+	if(gSavedSettings.getBOOL("MediaPerformanceManagerDebug"))
+	{
+		// Give impls the same ordering as the priority list
+		// they're already in the right order for this.
+	}
+	else
+	{
+		// Use a distance-based sort for proximity values.  
+		std::stable_sort(proximity_order.begin(), proximity_order.end(), proximity_comparitor);
+	}
+
+	// Transfer the proximity order to the proximity fields in the objects.
+	for(int i = 0; i < (int)proximity_order.size(); i++)
+	{
+		proximity_order[i]->mProximity = i;
 	}
 	
 	LL_DEBUGS("PluginPriority") << "Total reported CPU usage is " << total_cpu << llendl;
@@ -698,6 +813,8 @@ LLViewerMediaImpl::LLViewerMediaImpl(	  const LLUUID& texture_id,
 	mIsDisabled(false),
 	mIsParcelMedia(false),
 	mProximity(-1),
+	mProximityDistance(0.0f),
+	mMimeTypeProbe(NULL),
 	mIsUpdated(false)
 { 
 
@@ -801,7 +918,9 @@ void LLViewerMediaImpl::destroyMediaSource()
 	{
 		oldImage->setPlaying(FALSE) ;
 	}
-
+	
+	cancelMimeTypeProbe();
+	
 	if(mMediaSource)
 	{
 		delete mMediaSource;
@@ -847,7 +966,7 @@ LLPluginClassMedia* LLViewerMediaImpl::newSourceFromMediaType(std::string media_
 		{
 			LLPluginClassMedia* media_source = new LLPluginClassMedia(owner);
 			media_source->setSize(default_width, default_height);
-			if (media_source->init(launcher_name, plugin_name))
+			if (media_source->init(launcher_name, plugin_name, gSavedSettings.getBOOL("PluginAttachDebuggerToPlugins")))
 			{
 				return media_source;
 			}
@@ -992,15 +1111,7 @@ void LLViewerMediaImpl::stop()
 {
 	if(mMediaSource)
 	{
-		if(mMediaSource->pluginSupportsMediaBrowser())
-		{
-			mMediaSource->browse_stop();
-		}
-		else
-		{
-			mMediaSource->stop();
-		}
-
+		mMediaSource->stop();
 		// destroyMediaSource();
 	}
 }
@@ -1033,6 +1144,40 @@ void LLViewerMediaImpl::seek(F32 time)
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::skipBack(F32 step_scale)
+{
+	if(mMediaSource)
+	{
+		if(mMediaSource->pluginSupportsMediaTime())
+		{
+			F64 back_step = mMediaSource->getCurrentTime() - (mMediaSource->getDuration()*step_scale);
+			if(back_step < 0.0)
+			{
+				back_step = 0.0;
+			}
+			mMediaSource->seek(back_step);
+		}
+	}
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::skipForward(F32 step_scale)
+{
+	if(mMediaSource)
+	{
+		if(mMediaSource->pluginSupportsMediaTime())
+		{
+			F64 forward_step = mMediaSource->getCurrentTime() + (mMediaSource->getDuration()*step_scale);
+			if(forward_step > mMediaSource->getDuration())
+			{
+				forward_step = mMediaSource->getDuration();
+			}
+			mMediaSource->seek(forward_step);
+		}
+	}
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::setVolume(F32 volume)
 {
 	mRequestedVolume = volume;
@@ -1133,11 +1278,15 @@ void LLViewerMediaImpl::mouseMove(S32 x, S32 y, MASK mask)
 void LLViewerMediaImpl::mouseDown(const LLVector2& texture_coords, MASK mask, S32 button)
 {
 	if(mMediaSource)
-	{		
-		mouseDown(
-			llround(texture_coords.mV[VX] * mMediaSource->getTextureWidth()),
-			llround((1.0f - texture_coords.mV[VY]) * mMediaSource->getTextureHeight()),
-			mask, button);
+	{
+		// scale x and y to texel units.
+		S32 x = llround(texture_coords.mV[VX] * mMediaSource->getTextureWidth());
+		S32 y = llround((1.0f - texture_coords.mV[VY]) * mMediaSource->getTextureHeight());
+
+		// Adjust for the difference between the actual texture height and the amount of the texture in use.
+		y -= (mMediaSource->getTextureHeight() - mMediaSource->getHeight());
+
+		mouseDown(x, y, mask, button);
 	}
 }
 
@@ -1145,10 +1294,14 @@ void LLViewerMediaImpl::mouseUp(const LLVector2& texture_coords, MASK mask, S32
 {
 	if(mMediaSource)
 	{		
-		mouseUp(
-			llround(texture_coords.mV[VX] * mMediaSource->getTextureWidth()),
-			llround((1.0f - texture_coords.mV[VY]) * mMediaSource->getTextureHeight()),
-			mask, button);
+		// scale x and y to texel units.
+		S32 x = llround(texture_coords.mV[VX] * mMediaSource->getTextureWidth());
+		S32 y = llround((1.0f - texture_coords.mV[VY]) * mMediaSource->getTextureHeight());
+
+		// Adjust for the difference between the actual texture height and the amount of the texture in use.
+		y -= (mMediaSource->getTextureHeight() - mMediaSource->getHeight());
+
+		mouseUp(x, y, mask, button);
 	}
 }
 
@@ -1156,10 +1309,14 @@ void LLViewerMediaImpl::mouseMove(const LLVector2& texture_coords, MASK mask)
 {
 	if(mMediaSource)
 	{		
-		mouseMove(
-			llround(texture_coords.mV[VX] * mMediaSource->getTextureWidth()),
-			llround((1.0f - texture_coords.mV[VY]) * mMediaSource->getTextureHeight()),
-			mask);
+		// scale x and y to texel units.
+		S32 x = llround(texture_coords.mV[VX] * mMediaSource->getTextureWidth());
+		S32 y = llround((1.0f - texture_coords.mV[VY]) * mMediaSource->getTextureHeight());
+
+		// Adjust for the difference between the actual texture height and the amount of the texture in use.
+		y -= (mMediaSource->getTextureHeight() - mMediaSource->getHeight());
+
+		mouseMove(x, y, mask);
 	}
 }
 
@@ -1227,21 +1384,7 @@ void LLViewerMediaImpl::navigateBack()
 {
 	if (mMediaSource)
 	{
-		if(mMediaSource->pluginSupportsMediaTime())
-		{
-			F64 step_scale = 0.02; // temp , can be changed
-			F64 back_step = mMediaSource->getCurrentTime() - (mMediaSource->getDuration()*step_scale);
-			if(back_step < 0.0)
-			{
-				back_step = 0.0;
-			}
-			mMediaSource->seek(back_step);
-			//mMediaSource->start(-2.0);
-		}
-		else
-		{
-			mMediaSource->browse_back();
-		}
+		mMediaSource->browse_back();
 	}
 }
 
@@ -1250,21 +1393,7 @@ void LLViewerMediaImpl::navigateForward()
 {
 	if (mMediaSource)
 	{
-		if(mMediaSource->pluginSupportsMediaTime())
-		{
-			F64 step_scale = 0.02; // temp , can be changed
-			F64 forward_step = mMediaSource->getCurrentTime() + (mMediaSource->getDuration()*step_scale);
-			if(forward_step > mMediaSource->getDuration())
-			{
-				forward_step = mMediaSource->getDuration();
-			}
-			mMediaSource->seek(forward_step);
-			//mMediaSource->start(2.0);
-		}
-		else
-		{
-			mMediaSource->browse_forward();
-		}
+		mMediaSource->browse_forward();
 	}
 }
 
@@ -1294,6 +1423,8 @@ void LLViewerMediaImpl::unload()
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::navigateTo(const std::string& url, const std::string& mime_type,  bool rediscover_type, bool server_request)
 {
+	cancelMimeTypeProbe();
+
 	if(mMediaURL != url)
 	{
 		// Don't carry media play state across distinct URLs.
@@ -1336,6 +1467,12 @@ void LLViewerMediaImpl::navigateInternal()
 	// Helpful to have media urls in log file. Shouldn't be spammy.
 	llinfos << "media id= " << mTextureId << " url=" << mMediaURL << " mime_type=" << mMimeType << llendl;
 
+	if(mMimeTypeProbe != NULL)
+	{
+		llwarns << "MIME type probe already in progress -- bailing out." << llendl;
+		return;
+	}
+	
 	if(mNavigateServerRequest)
 	{
 		setNavState(MEDIANAVSTATE_SERVER_SENT);
@@ -1368,7 +1505,7 @@ void LLViewerMediaImpl::navigateInternal()
 
 		if(scheme.empty() || "http" == scheme || "https" == scheme)
 		{
-			LLHTTPClient::getHeaderOnly( mMediaURL, new LLMimeDiscoveryResponder(this));
+			LLHTTPClient::getHeaderOnly( mMediaURL, new LLMimeDiscoveryResponder(this), 10.0f);
 		}
 		else if("data" == scheme || "file" == scheme || "about" == scheme)
 		{
@@ -1405,7 +1542,6 @@ void LLViewerMediaImpl::navigateStop()
 	{
 		mMediaSource->browse_stop();
 	}
-
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -1499,7 +1635,19 @@ void LLViewerMediaImpl::update()
 {
 	if(mMediaSource == NULL)
 	{
-		if(mPriority != LLPluginClassMedia::PRIORITY_UNLOADED)
+		if(mPriority == LLPluginClassMedia::PRIORITY_UNLOADED)
+		{
+			// This media source should not be loaded.
+		}
+		else if(mPriority <= LLPluginClassMedia::PRIORITY_SLIDESHOW)
+		{
+			// Don't load new instances that are at PRIORITY_SLIDESHOW or below.  They're just kept around to preserve state.
+		}
+		else if(mMimeTypeProbe != NULL)
+		{
+			// this media source is doing a MIME type probe -- don't try loading it again.
+		}
+		else
 		{
 			// This media may need to be loaded.
 			if(sMediaCreateTimer.hasExpired())
@@ -1622,7 +1770,7 @@ LLViewerMediaTexture* LLViewerMediaImpl::updatePlaceholderImage()
 		// MEDIAOPT: seems insane that we actually have to make an imageraw then
 		// immediately discard it
 		LLPointer<LLImageRaw> raw = new LLImageRaw(texture_width, texture_height, texture_depth);
-		raw->clear(0x0f, 0x0f, 0x0f, 0xff);
+		raw->clear(0x00, 0x00, 0x00, 0xff);
 		int discard_level = 0;
 
 		// ask media source for correct GL image format constants
@@ -1723,7 +1871,7 @@ bool LLViewerMediaImpl::isMediaPaused()
 
 //////////////////////////////////////////////////////////////////////////////////////////
 //
-bool LLViewerMediaImpl::hasMedia()
+bool LLViewerMediaImpl::hasMedia() const
 {
 	return mMediaSource != NULL;
 }
@@ -1758,6 +1906,31 @@ bool LLViewerMediaImpl::isForcedUnloaded() const
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
+//
+bool LLViewerMediaImpl::isPlayable() const
+{
+	if(isForcedUnloaded())
+	{
+		// All of the forced-unloaded criteria also imply not playable.
+		return false;
+	}
+	
+	if(hasMedia())
+	{
+		// Anything that's already playing is, by definition, playable.
+		return true;
+	}
+	
+	if(!mMediaURL.empty())
+	{
+		// If something has navigated the instance, it's ready to be played.
+		return true;
+	}
+	
+	return false;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::handleMediaEvent(LLPluginClassMedia* plugin, LLPluginClassMediaOwner::EMediaEvent event)
 {
 	switch(event)
@@ -1965,6 +2138,15 @@ void LLViewerMediaImpl::calculateInterest()
 		mInterest = 0.0f;
 	}
 	
+	// Calculate distance from the avatar, for use in the proximity calculation.
+	mProximityDistance = 0.0f;
+	if(!mObjectList.empty())
+	{
+		// Just use the first object in the list.  We could go through the list and find the closest object, but this should work well enough.
+		LLVector3d global_delta = gAgent.getPositionGlobal() - (*mObjectList.begin())->getPositionGlobal();
+		mProximityDistance = global_delta.magVecSquared();  // use distance-squared because it's cheaper and sorts the same.
+	}
+	
 	if(mNeedsMuteCheck)
 	{
 		// Check all objects this instance is associated with, and those objects' owners, against the mute list
@@ -2001,7 +2183,13 @@ F64 LLViewerMediaImpl::getApproximateTextureInterest()
 		result = mMediaSource->getFullWidth();
 		result *= mMediaSource->getFullHeight();
 	}
-	
+	else
+	{
+		// No media source is loaded -- all we have to go on is the texture size that has been set on the impl, if any.
+		result = mMediaWidth;
+		result *= mMediaHeight;
+	}
+
 	return result;
 }
 
@@ -2042,7 +2230,7 @@ void LLViewerMediaImpl::setPriority(LLPluginClassMedia::EPriority priority)
 {
 	if(mPriority != priority)
 	{
-		LL_INFOS("PluginPriority")
+		LL_DEBUGS("PluginPriority")
 			<< "changing priority of media id " << mTextureId
 			<< " from " << LLPluginClassMedia::priorityToString(mPriority)
 			<< " to " << LLPluginClassMedia::priorityToString(priority)
@@ -2098,6 +2286,21 @@ void LLViewerMediaImpl::setNavState(EMediaNavState state)
 	}
 }
 
+void LLViewerMediaImpl::cancelMimeTypeProbe()
+{
+	if(mMimeTypeProbe != NULL)
+	{
+		// There doesn't seem to be a way to actually cancel an outstanding request.
+		// Simulate it by telling the LLMimeDiscoveryResponder not to write back any results.
+		mMimeTypeProbe->cancelRequest();
+		
+		// The above should already have set mMimeTypeProbe to NULL.
+		if(mMimeTypeProbe != NULL)
+		{
+			llerrs << "internal error: mMimeTypeProbe is not NULL after cancelling request." << llendl;
+		}
+	}
+}
 
 void LLViewerMediaImpl::addObject(LLVOVolume* obj) 
 {