Merge remote-tracking branch 'origin/DRTVWR-600-maint-A' into brad/merge-maint-a-to-dev

1 files changed, 2222 insertions, 2222 deletions

diff --git a/indra/newview/llviewermedia.cpp b/indra/newview/llviewermedia.cpp
index f32bbdf3c2..f7d9c12e66 100644
--- a/indra/newview/llviewermedia.cpp
+++ b/indra/newview/llviewermedia.cpp
@@ -35,9 +35,9 @@
 #include "llcallbacklist.h"
 #include "lldir.h"
 #include "lldiriterator.h"
-#include "llevent.h"		// LLSimpleListener
+#include "llevent.h"        // LLSimpleListener
 #include "llfilepicker.h"
-#include "llfloaterwebcontent.h"	// for handling window close requests and geometry change requests in media browser windows.
+#include "llfloaterwebcontent.h"    // for handling window close requests and geometry change requests in media browser windows.
 #include "llfocusmgr.h"
 #include "llimagegl.h"
 #include "llkeyboard.h"
@@ -74,9 +74,9 @@
 #include "llvieweraudio.h"
 #include "llcorehttputil.h"
 
-#include "llfloaterwebcontent.h"	// for handling window close requests and geometry change requests in media browser windows.
+#include "llfloaterwebcontent.h"    // for handling window close requests and geometry change requests in media browser windows.
 
-#include <boost/bind.hpp>	// for SkinFolder listener
+#include <boost/bind.hpp>   // for SkinFolder listener
 #include <boost/signals2.hpp>
 
 extern bool gCubeSnapshot;
@@ -95,70 +95,70 @@ void init_threaded_picker_load_dialog(LLPluginClassMedia* plugin, LLFilePicker::
 
 LLViewerMediaEventEmitter::~LLViewerMediaEventEmitter()
 {
-	observerListType::iterator iter = mObservers.begin();
+    observerListType::iterator iter = mObservers.begin();
 
-	while( iter != mObservers.end() )
-	{
-		LLViewerMediaObserver *self = *iter;
-		iter++;
-		remObserver(self);
-	}
+    while( iter != mObservers.end() )
+    {
+        LLViewerMediaObserver *self = *iter;
+        iter++;
+        remObserver(self);
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 bool LLViewerMediaEventEmitter::addObserver( LLViewerMediaObserver* observer )
 {
-	if ( ! observer )
-		return false;
+    if ( ! observer )
+        return false;
 
-	if ( std::find( mObservers.begin(), mObservers.end(), observer ) != mObservers.end() )
-		return false;
+    if ( std::find( mObservers.begin(), mObservers.end(), observer ) != mObservers.end() )
+        return false;
 
-	mObservers.push_back( observer );
-	observer->mEmitters.push_back( this );
+    mObservers.push_back( observer );
+    observer->mEmitters.push_back( this );
 
-	return true;
+    return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 bool LLViewerMediaEventEmitter::remObserver( LLViewerMediaObserver* observer )
 {
-	if ( ! observer )
-		return false;
+    if ( ! observer )
+        return false;
 
-	mObservers.remove( observer );
-	observer->mEmitters.remove(this);
+    mObservers.remove( observer );
+    observer->mEmitters.remove(this);
 
-	return true;
+    return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 void LLViewerMediaEventEmitter::emitEvent( LLPluginClassMedia* media, LLViewerMediaObserver::EMediaEvent event )
 {
-	// Broadcast the event to any observers.
-	observerListType::iterator iter = mObservers.begin();
-	while( iter != mObservers.end() )
-	{
-		LLViewerMediaObserver *self = *iter;
-		++iter;
-		self->handleMediaEvent( media, event );
-	}
+    // Broadcast the event to any observers.
+    observerListType::iterator iter = mObservers.begin();
+    while( iter != mObservers.end() )
+    {
+        LLViewerMediaObserver *self = *iter;
+        ++iter;
+        self->handleMediaEvent( media, event );
+    }
 }
 
 // Move this to its own file.
 LLViewerMediaObserver::~LLViewerMediaObserver()
 {
-	std::list<LLViewerMediaEventEmitter *>::iterator iter = mEmitters.begin();
+    std::list<LLViewerMediaEventEmitter *>::iterator iter = mEmitters.begin();
 
-	while( iter != mEmitters.end() )
-	{
-		LLViewerMediaEventEmitter *self = *iter;
-		iter++;
-		self->remObserver( this );
-	}
+    while( iter != mEmitters.end() )
+    {
+        LLViewerMediaEventEmitter *self = *iter;
+        iter++;
+        self->remObserver( this );
+    }
 }
 
 
@@ -174,28 +174,28 @@ static F64 sLowestLoadableImplInterest = 0.0f;
 //////////////////////////////////////////////////////////////////////////////////////////
 static void add_media_impl(LLViewerMediaImpl* media)
 {
-	sViewerMediaImplList.push_back(media);
+    sViewerMediaImplList.push_back(media);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 static void remove_media_impl(LLViewerMediaImpl* media)
 {
-	LLViewerMedia::impl_list::iterator iter = sViewerMediaImplList.begin();
-	LLViewerMedia::impl_list::iterator end = sViewerMediaImplList.end();
+    LLViewerMedia::impl_list::iterator iter = sViewerMediaImplList.begin();
+    LLViewerMedia::impl_list::iterator end = sViewerMediaImplList.end();
 
-	for(; iter != end; iter++)
-	{
-		if(media == *iter)
-		{
-			sViewerMediaImplList.erase(iter);
-			return;
-		}
-	}
+    for(; iter != end; iter++)
+    {
+        if(media == *iter)
+        {
+            sViewerMediaImplList.erase(iter);
+            return;
+        }
+    }
 }
 
 class LLViewerMediaMuteListObserver : public LLMuteListObserver
 {
-	/* virtual */ void onChange()  { LLViewerMedia::getInstance()->muteListChanged();}
+    /* virtual */ void onChange()  { LLViewerMedia::getInstance()->muteListChanged();}
 };
 
 static LLViewerMediaMuteListObserver sViewerMediaMuteListObserver;
@@ -239,374 +239,374 @@ void LLViewerMedia::initSingleton()
 
 //////////////////////////////////////////////////////////////////////////////////////////
 viewer_media_t LLViewerMedia::newMediaImpl(
-											 const LLUUID& texture_id,
-											 S32 media_width,
-											 S32 media_height,
-											 U8 media_auto_scale,
-											 U8 media_loop)
-{
-	LLViewerMediaImpl* media_impl = getMediaImplFromTextureID(texture_id);
-	if(media_impl == NULL || texture_id.isNull())
-	{
-		// Create the media impl
-		media_impl = new LLViewerMediaImpl(texture_id, media_width, media_height, media_auto_scale, media_loop);
-	}
-	else
-	{
-		media_impl->unload();
-		media_impl->setTextureID(texture_id);
-		media_impl->mMediaWidth = media_width;
-		media_impl->mMediaHeight = media_height;
-		media_impl->mMediaAutoScale = media_auto_scale;
-		media_impl->mMediaLoop = media_loop;
-	}
-
-	return media_impl;
+                                             const LLUUID& texture_id,
+                                             S32 media_width,
+                                             S32 media_height,
+                                             U8 media_auto_scale,
+                                             U8 media_loop)
+{
+    LLViewerMediaImpl* media_impl = getMediaImplFromTextureID(texture_id);
+    if(media_impl == NULL || texture_id.isNull())
+    {
+        // Create the media impl
+        media_impl = new LLViewerMediaImpl(texture_id, media_width, media_height, media_auto_scale, media_loop);
+    }
+    else
+    {
+        media_impl->unload();
+        media_impl->setTextureID(texture_id);
+        media_impl->mMediaWidth = media_width;
+        media_impl->mMediaHeight = media_height;
+        media_impl->mMediaAutoScale = media_auto_scale;
+        media_impl->mMediaLoop = media_loop;
+    }
+
+    return media_impl;
 }
 
 viewer_media_t LLViewerMedia::updateMediaImpl(LLMediaEntry* media_entry, const std::string& previous_url, bool update_from_self)
 {
     llassert(!gCubeSnapshot);
-	// Try to find media with the same media ID
-	viewer_media_t media_impl = getMediaImplFromTextureID(media_entry->getMediaID());
-
-	LL_DEBUGS() << "called, current URL is \"" << media_entry->getCurrentURL()
-			<< "\", previous URL is \"" << previous_url
-			<< "\", update_from_self is " << (update_from_self?"true":"false")
-			<< LL_ENDL;
-
-	bool was_loaded = false;
-	bool needs_navigate = false;
-
-	if(media_impl)
-	{
-		was_loaded = media_impl->hasMedia();
-
-		media_impl->setHomeURL(media_entry->getHomeURL());
-
-		media_impl->mMediaAutoScale = media_entry->getAutoScale();
-		media_impl->mMediaLoop = media_entry->getAutoLoop();
-		media_impl->mMediaWidth = media_entry->getWidthPixels();
-		media_impl->mMediaHeight = media_entry->getHeightPixels();
-		media_impl->mMediaAutoPlay = media_entry->getAutoPlay();
-		media_impl->mMediaEntryURL = media_entry->getCurrentURL();
-		if (media_impl->mMediaSource)
-		{
-			media_impl->mMediaSource->setAutoScale(media_impl->mMediaAutoScale);
-			media_impl->mMediaSource->setLoop(media_impl->mMediaLoop);
-			media_impl->mMediaSource->setSize(media_entry->getWidthPixels(), media_entry->getHeightPixels());
-		}
-
-		bool url_changed = (media_impl->mMediaEntryURL != previous_url);
-		if(media_impl->mMediaEntryURL.empty())
-		{
-			if(url_changed)
-			{
-				// The current media URL is now empty.  Unload the media source.
-				media_impl->unload();
-
-				LL_DEBUGS() << "Unloading media instance (new current URL is empty)." << LL_ENDL;
-			}
-		}
-		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_impl->isAutoPlayable();
-			if((was_loaded || auto_play) && !update_from_self)
-			{
-				needs_navigate = url_changed;
-			}
-
-			LL_DEBUGS() << "was_loaded is " << (was_loaded?"true":"false")
-					<< ", auto_play is " << (auto_play?"true":"false")
-					<< ", needs_navigate is " << (needs_navigate?"true":"false") << LL_ENDL;
-		}
-	}
-	else
-	{
-		media_impl = newMediaImpl(
-			media_entry->getMediaID(),
-			media_entry->getWidthPixels(),
-			media_entry->getHeightPixels(),
-			media_entry->getAutoScale(),
-			media_entry->getAutoLoop());
-
-		media_impl->setHomeURL(media_entry->getHomeURL());
-		media_impl->mMediaAutoPlay = media_entry->getAutoPlay();
-		media_impl->mMediaEntryURL = media_entry->getCurrentURL();
-		if(media_impl->isAutoPlayable())
-		{
-			needs_navigate = true;
-		}
-	}
-
-	if(media_impl)
-	{
-		if(needs_navigate)
-		{
-			media_impl->navigateTo(media_impl->mMediaEntryURL, "", true, true);
-			LL_DEBUGS() << "navigating to URL " << media_impl->mMediaEntryURL << LL_ENDL;
-		}
-		else if(!media_impl->mMediaURL.empty() && (media_impl->mMediaURL != media_impl->mMediaEntryURL))
-		{
-			// 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 = media_impl->mMediaEntryURL;
-
-			// 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;
-
-			LL_DEBUGS() << "updating URL in the media impl to " << media_impl->mMediaEntryURL << LL_ENDL;
-		}
-	}
-
-	return media_impl;
+    // Try to find media with the same media ID
+    viewer_media_t media_impl = getMediaImplFromTextureID(media_entry->getMediaID());
+
+    LL_DEBUGS() << "called, current URL is \"" << media_entry->getCurrentURL()
+            << "\", previous URL is \"" << previous_url
+            << "\", update_from_self is " << (update_from_self?"true":"false")
+            << LL_ENDL;
+
+    bool was_loaded = false;
+    bool needs_navigate = false;
+
+    if(media_impl)
+    {
+        was_loaded = media_impl->hasMedia();
+
+        media_impl->setHomeURL(media_entry->getHomeURL());
+
+        media_impl->mMediaAutoScale = media_entry->getAutoScale();
+        media_impl->mMediaLoop = media_entry->getAutoLoop();
+        media_impl->mMediaWidth = media_entry->getWidthPixels();
+        media_impl->mMediaHeight = media_entry->getHeightPixels();
+        media_impl->mMediaAutoPlay = media_entry->getAutoPlay();
+        media_impl->mMediaEntryURL = media_entry->getCurrentURL();
+        if (media_impl->mMediaSource)
+        {
+            media_impl->mMediaSource->setAutoScale(media_impl->mMediaAutoScale);
+            media_impl->mMediaSource->setLoop(media_impl->mMediaLoop);
+            media_impl->mMediaSource->setSize(media_entry->getWidthPixels(), media_entry->getHeightPixels());
+        }
+
+        bool url_changed = (media_impl->mMediaEntryURL != previous_url);
+        if(media_impl->mMediaEntryURL.empty())
+        {
+            if(url_changed)
+            {
+                // The current media URL is now empty.  Unload the media source.
+                media_impl->unload();
+
+                LL_DEBUGS() << "Unloading media instance (new current URL is empty)." << LL_ENDL;
+            }
+        }
+        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_impl->isAutoPlayable();
+            if((was_loaded || auto_play) && !update_from_self)
+            {
+                needs_navigate = url_changed;
+            }
+
+            LL_DEBUGS() << "was_loaded is " << (was_loaded?"true":"false")
+                    << ", auto_play is " << (auto_play?"true":"false")
+                    << ", needs_navigate is " << (needs_navigate?"true":"false") << LL_ENDL;
+        }
+    }
+    else
+    {
+        media_impl = newMediaImpl(
+            media_entry->getMediaID(),
+            media_entry->getWidthPixels(),
+            media_entry->getHeightPixels(),
+            media_entry->getAutoScale(),
+            media_entry->getAutoLoop());
+
+        media_impl->setHomeURL(media_entry->getHomeURL());
+        media_impl->mMediaAutoPlay = media_entry->getAutoPlay();
+        media_impl->mMediaEntryURL = media_entry->getCurrentURL();
+        if(media_impl->isAutoPlayable())
+        {
+            needs_navigate = true;
+        }
+    }
+
+    if(media_impl)
+    {
+        if(needs_navigate)
+        {
+            media_impl->navigateTo(media_impl->mMediaEntryURL, "", true, true);
+            LL_DEBUGS() << "navigating to URL " << media_impl->mMediaEntryURL << LL_ENDL;
+        }
+        else if(!media_impl->mMediaURL.empty() && (media_impl->mMediaURL != media_impl->mMediaEntryURL))
+        {
+            // 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 = media_impl->mMediaEntryURL;
+
+            // 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;
+
+            LL_DEBUGS() << "updating URL in the media impl to " << media_impl->mMediaEntryURL << LL_ENDL;
+        }
+    }
+
+    return media_impl;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 LLViewerMediaImpl* LLViewerMedia::getMediaImplFromTextureID(const LLUUID& texture_id)
 {
-	LLViewerMediaImpl* result = NULL;
+    LLViewerMediaImpl* result = NULL;
 
-	// Look up the texture ID in the texture id->impl map.
-	impl_id_map::iterator iter = sViewerMediaTextureIDMap.find(texture_id);
-	if(iter != sViewerMediaTextureIDMap.end())
-	{
-		result = iter->second;
-	}
+    // Look up the texture ID in the texture id->impl map.
+    impl_id_map::iterator iter = sViewerMediaTextureIDMap.find(texture_id);
+    if(iter != sViewerMediaTextureIDMap.end())
+    {
+        result = iter->second;
+    }
 
-	return result;
+    return result;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 std::string LLViewerMedia::getCurrentUserAgent()
 {
-	// Don't use user-visible string to avoid
-	// punctuation and strange characters.
-	std::string skin_name = gSavedSettings.getString("SkinCurrent");
+    // Don't use user-visible string to avoid
+    // punctuation and strange characters.
+    std::string skin_name = gSavedSettings.getString("SkinCurrent");
 
-	// Just in case we need to check browser differences in A/B test
-	// builds.
-	std::string channel = LLVersionInfo::instance().getChannel();
+    // Just in case we need to check browser differences in A/B test
+    // builds.
+    std::string channel = LLVersionInfo::instance().getChannel();
 
-	// append our magic version number string to the browser user agent id
-	// See the HTTP 1.0 and 1.1 specifications for allowed formats:
-	// http://www.ietf.org/rfc/rfc1945.txt section 10.15
-	// http://www.ietf.org/rfc/rfc2068.txt section 3.8
-	// This was also helpful:
-	// http://www.mozilla.org/build/revised-user-agent-strings.html
-	std::ostringstream codec;
-	codec << "SecondLife/";
-	codec << LLVersionInfo::instance().getVersion();
-	codec << " (" << channel << "; " << skin_name << " skin)";
-	LL_INFOS() << codec.str() << LL_ENDL;
+    // append our magic version number string to the browser user agent id
+    // See the HTTP 1.0 and 1.1 specifications for allowed formats:
+    // http://www.ietf.org/rfc/rfc1945.txt section 10.15
+    // http://www.ietf.org/rfc/rfc2068.txt section 3.8
+    // This was also helpful:
+    // http://www.mozilla.org/build/revised-user-agent-strings.html
+    std::ostringstream codec;
+    codec << "SecondLife/";
+    codec << LLVersionInfo::instance().getVersion();
+    codec << " (" << channel << "; " << skin_name << " skin)";
+    LL_INFOS() << codec.str() << LL_ENDL;
 
-	return codec.str();
+    return codec.str();
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMedia::updateBrowserUserAgent()
 {
-	std::string user_agent = getCurrentUserAgent();
+    std::string user_agent = getCurrentUserAgent();
 
-	impl_list::iterator iter = sViewerMediaImplList.begin();
-	impl_list::iterator end = sViewerMediaImplList.end();
+    impl_list::iterator iter = sViewerMediaImplList.begin();
+    impl_list::iterator end = sViewerMediaImplList.end();
 
-	for(; iter != end; iter++)
-	{
-		LLViewerMediaImpl* pimpl = *iter;
-		if(pimpl->mMediaSource && pimpl->mMediaSource->pluginSupportsMediaBrowser())
-		{
-			pimpl->mMediaSource->setBrowserUserAgent(user_agent);
-		}
-	}
+    for(; iter != end; iter++)
+    {
+        LLViewerMediaImpl* pimpl = *iter;
+        if(pimpl->mMediaSource && pimpl->mMediaSource->pluginSupportsMediaBrowser())
+        {
+            pimpl->mMediaSource->setBrowserUserAgent(user_agent);
+        }
+    }
 
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMedia::handleSkinCurrentChanged(const LLSD& /*newvalue*/)
 {
-	// gSavedSettings is already updated when this function is called.
-	updateBrowserUserAgent();
-	return true;
+    // gSavedSettings is already updated when this function is called.
+    updateBrowserUserAgent();
+    return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMedia::textureHasMedia(const LLUUID& texture_id)
 {
-	impl_list::iterator iter = sViewerMediaImplList.begin();
-	impl_list::iterator end = sViewerMediaImplList.end();
+    impl_list::iterator iter = sViewerMediaImplList.begin();
+    impl_list::iterator end = sViewerMediaImplList.end();
 
-	for(; iter != end; iter++)
-	{
-		LLViewerMediaImpl* pimpl = *iter;
-		if(pimpl->getMediaTextureID() == texture_id)
-		{
-			return true;
-		}
-	}
-	return false;
+    for(; iter != end; iter++)
+    {
+        LLViewerMediaImpl* pimpl = *iter;
+        if(pimpl->getMediaTextureID() == texture_id)
+        {
+            return true;
+        }
+    }
+    return false;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMedia::setVolume(F32 volume)
 {
-	if(volume != sGlobalVolume || sForceUpdate)
-	{
-		sGlobalVolume = volume;
-		impl_list::iterator iter = sViewerMediaImplList.begin();
-		impl_list::iterator end = sViewerMediaImplList.end();
+    if(volume != sGlobalVolume || sForceUpdate)
+    {
+        sGlobalVolume = volume;
+        impl_list::iterator iter = sViewerMediaImplList.begin();
+        impl_list::iterator end = sViewerMediaImplList.end();
 
-		for(; iter != end; iter++)
-		{
-			LLViewerMediaImpl* pimpl = *iter;
-			pimpl->updateVolume();
-		}
+        for(; iter != end; iter++)
+        {
+            LLViewerMediaImpl* pimpl = *iter;
+            pimpl->updateVolume();
+        }
 
-		sForceUpdate = false;
-	}
+        sForceUpdate = false;
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 F32 LLViewerMedia::getVolume()
 {
-	return sGlobalVolume;
+    return sGlobalVolume;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMedia::muteListChanged()
 {
-	// When the mute list changes, we need to check mute status on all impls.
-	impl_list::iterator iter = sViewerMediaImplList.begin();
-	impl_list::iterator end = sViewerMediaImplList.end();
+    // When the mute list changes, we need to check mute status on all impls.
+    impl_list::iterator iter = sViewerMediaImplList.begin();
+    impl_list::iterator end = sViewerMediaImplList.end();
 
-	for(; iter != end; iter++)
-	{
-		LLViewerMediaImpl* pimpl = *iter;
-		pimpl->mNeedsMuteCheck = true;
-	}
+    for(; iter != end; iter++)
+    {
+        LLViewerMediaImpl* pimpl = *iter;
+        pimpl->mNeedsMuteCheck = true;
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMedia::isInterestingEnough(const LLVOVolume *object, const F64 &object_interest)
 {
-	bool result = false;
-
-	if (NULL == object)
-	{
-		result = false;
-	}
-	// Focused?  Then it is interesting!
-	else if (LLViewerMediaFocus::getInstance()->getFocusedObjectID() == object->getID())
-	{
-		result = true;
-	}
-	// Selected?  Then it is interesting!
-	// XXX Sadly, 'contains()' doesn't take a const :(
-	else if (LLSelectMgr::getInstance()->getSelection()->contains(const_cast<LLVOVolume*>(object)))
-	{
-		result = true;
-	}
-	else
-	{
-		LL_DEBUGS() << "object interest = " << object_interest << ", lowest loadable = " << sLowestLoadableImplInterest << LL_ENDL;
-		if(object_interest >= sLowestLoadableImplInterest)
-			result = true;
-	}
-
-	return result;
+    bool result = false;
+
+    if (NULL == object)
+    {
+        result = false;
+    }
+    // Focused?  Then it is interesting!
+    else if (LLViewerMediaFocus::getInstance()->getFocusedObjectID() == object->getID())
+    {
+        result = true;
+    }
+    // Selected?  Then it is interesting!
+    // XXX Sadly, 'contains()' doesn't take a const :(
+    else if (LLSelectMgr::getInstance()->getSelection()->contains(const_cast<LLVOVolume*>(object)))
+    {
+        result = true;
+    }
+    else
+    {
+        LL_DEBUGS() << "object interest = " << object_interest << ", lowest loadable = " << sLowestLoadableImplInterest << LL_ENDL;
+        if(object_interest >= sLowestLoadableImplInterest)
+            result = true;
+    }
+
+    return result;
 }
 
 LLViewerMedia::impl_list &LLViewerMedia::getPriorityList()
 {
-	return sViewerMediaImplList;
+    return sViewerMediaImplList;
 }
 
 // static
 // This is the predicate function used to sort sViewerMediaImplList by priority.
 bool LLViewerMedia::priorityComparitor(const LLViewerMediaImpl* i1, const LLViewerMediaImpl* i2)
 {
-	if(i1->isForcedUnloaded() && !i2->isForcedUnloaded())
-	{
-		// Muted or failed items always go to the end of the list, period.
-		return false;
-	}
-	else if(i2->isForcedUnloaded() && !i1->isForcedUnloaded())
-	{
-		// Muted or failed items always go to the end of the list, period.
-		return true;
-	}
-	else if(i1->hasFocus())
-	{
-		// The item with user focus always comes to the front of the list, period.
-		return true;
-	}
-	else if(i2->hasFocus())
-	{
-		// 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.
-		return true;
-	}
-	else if(i2->getUsedInUI() && !i1->getUsedInUI())
-	{
-		// 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->isPlayable() && !i2->isPlayable())
-	{
-		// Playable items sort above ones that wouldn't play even if they got high enough priority
-		return true;
-	}
-	else if(!i1->isPlayable() && i2->isPlayable())
-	{
-		// 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.
-		return (i1->getInterest() > i2->getInterest());
-	}
+    if(i1->isForcedUnloaded() && !i2->isForcedUnloaded())
+    {
+        // Muted or failed items always go to the end of the list, period.
+        return false;
+    }
+    else if(i2->isForcedUnloaded() && !i1->isForcedUnloaded())
+    {
+        // Muted or failed items always go to the end of the list, period.
+        return true;
+    }
+    else if(i1->hasFocus())
+    {
+        // The item with user focus always comes to the front of the list, period.
+        return true;
+    }
+    else if(i2->hasFocus())
+    {
+        // 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.
+        return true;
+    }
+    else if(i2->getUsedInUI() && !i1->getUsedInUI())
+    {
+        // 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->isPlayable() && !i2->isPlayable())
+    {
+        // Playable items sort above ones that wouldn't play even if they got high enough priority
+        return true;
+    }
+    else if(!i1->isPlayable() && i2->isPlayable())
+    {
+        // 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.
+        return (i1->getInterest() > i2->getInterest());
+    }
 }
 
 static bool proximity_comparitor(const LLViewerMediaImpl* i1, const LLViewerMediaImpl* i2)
 {
-	if(i1->getProximityDistance() < i2->getProximityDistance())
-	{
-		return true;
-	}
-	else if(i1->getProximityDistance() > i2->getProximityDistance())
-	{
-		return false;
-	}
-	else
-	{
-		// Both objects have the same distance.  This most likely means they're two faces of the same object.
-		// They may also be faces on different objects with exactly the same distance (like HUD objects).
-		// We don't actually care what the sort order is for this case, as long as it's stable and doesn't change when you enable/disable media.
-		// Comparing the impl pointers gives a completely arbitrary ordering, but it will be stable.
-		return (i1 < i2);
-	}
+    if(i1->getProximityDistance() < i2->getProximityDistance())
+    {
+        return true;
+    }
+    else if(i1->getProximityDistance() > i2->getProximityDistance())
+    {
+        return false;
+    }
+    else
+    {
+        // Both objects have the same distance.  This most likely means they're two faces of the same object.
+        // They may also be faces on different objects with exactly the same distance (like HUD objects).
+        // We don't actually care what the sort order is for this case, as long as it's stable and doesn't change when you enable/disable media.
+        // Comparing the impl pointers gives a completely arbitrary ordering, but it will be stable.
+        return (i1 < i2);
+    }
 }
 
 static LLTrace::BlockTimerStatHandle FTM_MEDIA_UPDATE("Update Media");
@@ -631,8 +631,8 @@ void LLViewerMedia::updateMedia(void *dummy_arg)
 
     llassert(!gCubeSnapshot);
 
-	// Enable/disable the plugin read thread
-	LLPluginProcessParent::setUseReadThread(gSavedSettings.getBOOL("PluginUseReadThread"));
+    // Enable/disable the plugin read thread
+    LLPluginProcessParent::setUseReadThread(gSavedSettings.getBOOL("PluginUseReadThread"));
 
     // SL-16418 We can't call LLViewerMediaImpl->update() if we are in the state of shutting down.
     if(LLApp::isExiting())
@@ -641,192 +641,192 @@ void LLViewerMedia::updateMedia(void *dummy_arg)
         return;
     }
 
-	// HACK: we always try to keep a spare running webkit plugin around to improve launch times.
-	// 2017-04-19 Removed CP - this doesn't appear to buy us much and consumes a lot of resources so
-	// removing it for now.
-	//createSpareBrowserMediaSource();
+    // HACK: we always try to keep a spare running webkit plugin around to improve launch times.
+    // 2017-04-19 Removed CP - this doesn't appear to buy us much and consumes a lot of resources so
+    // removing it for now.
+    //createSpareBrowserMediaSource();
 
-	mAnyMediaShowing = false;
-	mAnyMediaPlaying = false;
+    mAnyMediaShowing = false;
+    mAnyMediaPlaying = false;
 
-	impl_list::iterator iter = sViewerMediaImplList.begin();
-	impl_list::iterator end = sViewerMediaImplList.end();
+    impl_list::iterator iter = sViewerMediaImplList.begin();
+    impl_list::iterator end = sViewerMediaImplList.end();
 
-	{
+    {
         LL_PROFILE_ZONE_NAMED_CATEGORY_MEDIA("media update interest"); //LL_RECORD_BLOCK_TIME(FTM_MEDIA_UPDATE_INTEREST);
-		for(; iter != end;)
-		{
-			LLViewerMediaImpl* pimpl = *iter++;
-			pimpl->update();
-			pimpl->calculateInterest();
-		}
-	}
-
-	// Let the spare media source actually launch
-	if(mSpareBrowserMediaSource)
-	{
+        for(; iter != end;)
+        {
+            LLViewerMediaImpl* pimpl = *iter++;
+            pimpl->update();
+            pimpl->calculateInterest();
+        }
+    }
+
+    // Let the spare media source actually launch
+    if(mSpareBrowserMediaSource)
+    {
         LL_PROFILE_ZONE_NAMED_CATEGORY_MEDIA("media spare idle"); //LL_RECORD_BLOCK_TIME(FTM_MEDIA_SPARE_IDLE);
-		mSpareBrowserMediaSource->idle();
-	}
+        mSpareBrowserMediaSource->idle();
+    }
 
-	{
+    {
         LL_PROFILE_ZONE_NAMED_CATEGORY_MEDIA("media sort"); //LL_RECORD_BLOCK_TIME(FTM_MEDIA_SORT);
-		// Sort the static instance list using our interest criteria
-		sViewerMediaImplList.sort(priorityComparitor);
-	}
+        // Sort the static instance list using our interest criteria
+        sViewerMediaImplList.sort(priorityComparitor);
+    }
 
-	// Go through the list again and adjust according to priority.
-	iter = sViewerMediaImplList.begin();
-	end = sViewerMediaImplList.end();
+    // Go through the list again and adjust according to priority.
+    iter = sViewerMediaImplList.begin();
+    end = sViewerMediaImplList.end();
 
-	F64 total_cpu = 0.0f;
-	int impl_count_total = 0;
-	int impl_count_interest_low = 0;
-	int impl_count_interest_normal = 0;
+    F64 total_cpu = 0.0f;
+    int impl_count_total = 0;
+    int impl_count_interest_low = 0;
+    int impl_count_interest_normal = 0;
 
-	std::vector<LLViewerMediaImpl*> proximity_order;
+    std::vector<LLViewerMediaImpl*> proximity_order;
 
-	static LLCachedControl<bool> inworld_media_enabled(gSavedSettings, "AudioStreamingMedia", true);
-	static LLCachedControl<bool> inworld_audio_enabled(gSavedSettings, "AudioStreamingMusic", true);
-	U32 max_instances = gSavedSettings.getU32("PluginInstancesTotal");
-	U32 max_normal = gSavedSettings.getU32("PluginInstancesNormal");
-	U32 max_low = gSavedSettings.getU32("PluginInstancesLow");
-	F32 max_cpu = gSavedSettings.getF32("PluginInstancesCPULimit");
-	// Setting max_cpu to 0.0 disables CPU usage checking.
-	bool check_cpu_usage = (max_cpu != 0.0f);
+    static LLCachedControl<bool> inworld_media_enabled(gSavedSettings, "AudioStreamingMedia", true);
+    static LLCachedControl<bool> inworld_audio_enabled(gSavedSettings, "AudioStreamingMusic", true);
+    U32 max_instances = gSavedSettings.getU32("PluginInstancesTotal");
+    U32 max_normal = gSavedSettings.getU32("PluginInstancesNormal");
+    U32 max_low = gSavedSettings.getU32("PluginInstancesLow");
+    F32 max_cpu = gSavedSettings.getF32("PluginInstancesCPULimit");
+    // Setting max_cpu to 0.0 disables CPU usage checking.
+    bool check_cpu_usage = (max_cpu != 0.0f);
 
-	LLViewerMediaImpl* lowest_interest_loadable = NULL;
+    LLViewerMediaImpl* lowest_interest_loadable = NULL;
 
-	// Notes on tweakable params:
-	// max_instances must be set high enough to allow the various instances used in the UI (for the help browser, search, etc.) to be loaded.
-	// If max_normal + max_low is less than max_instances, things will tend to get unloaded instead of being set to slideshow.
+    // Notes on tweakable params:
+    // max_instances must be set high enough to allow the various instances used in the UI (for the help browser, search, etc.) to be loaded.
+    // If max_normal + max_low is less than max_instances, things will tend to get unloaded instead of being set to slideshow.
 
-	{
+    {
         LL_PROFILE_ZONE_NAMED_CATEGORY_MEDIA("media misc"); //LL_RECORD_BLOCK_TIME(FTM_MEDIA_MISC);
-		for(; iter != end; iter++)
-		{
-			LLViewerMediaImpl* pimpl = *iter;
-
-			LLPluginClassMedia::EPriority new_priority = LLPluginClassMedia::PRIORITY_NORMAL;
-
-			if(pimpl->isForcedUnloaded() || (impl_count_total >= (int)max_instances))
-			{
-				// Never load muted or failed impls.
-				// Hard limit on the number of instances that will be loaded at one time
-				new_priority = LLPluginClassMedia::PRIORITY_UNLOADED;
-			}
-			else if(!pimpl->getVisible())
-			{
-				new_priority = LLPluginClassMedia::PRIORITY_HIDDEN;
-			}
-			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 if(pimpl->isParcelMedia())
-			{
-				new_priority = LLPluginClassMedia::PRIORITY_NORMAL;
-				impl_count_interest_normal++;
-			}
-			else
-			{
-				// Look at interest and CPU usage for instances that aren't in any of the above states.
-
-				// 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 = 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)
-				{
-					// This media is completely invisible, due to being outside the view frustrum or out of range.
-					new_priority = LLPluginClassMedia::PRIORITY_HIDDEN;
-				}
-				else if(check_cpu_usage && (total_cpu > max_cpu))
-				{
-					// Higher priority plugins have already used up the CPU budget.  Set remaining ones to slideshow priority.
-					new_priority = LLPluginClassMedia::PRIORITY_SLIDESHOW;
-				}
-				else if((impl_count_interest_normal < (int)max_normal) && !media_is_small)
-				{
-					// Up to max_normal inworld get normal priority
-					new_priority = LLPluginClassMedia::PRIORITY_NORMAL;
-					impl_count_interest_normal++;
-				}
-				else if (impl_count_interest_low + impl_count_interest_normal < (int)max_low + (int)max_normal)
-				{
-					// The next max_low inworld get turned down
-					new_priority = LLPluginClassMedia::PRIORITY_LOW;
-					impl_count_interest_low++;
-
-					// Set the low priority size for downsampling to approximately the size the texture is displayed at.
-					{
-						F32 approximate_interest_dimension = (F32) sqrt(pimpl->getInterest());
-
-						pimpl->setLowPrioritySizeLimit(ll_round(approximate_interest_dimension));
-					}
-				}
-				else
-				{
-					// Any additional impls (up to max_instances) get very infrequent time
-					new_priority = LLPluginClassMedia::PRIORITY_SLIDESHOW;
-				}
-			}
-
-			if(!pimpl->getUsedInUI() && (new_priority != LLPluginClassMedia::PRIORITY_UNLOADED))
-			{
-				// This is a loadable inworld impl -- the last one in the list in this class defines the lowest loadable interest.
-				lowest_interest_loadable = pimpl;
-
-				impl_count_total++;
-			}
-
-			// Overrides if the window is minimized or we lost focus (taking care
-			// not to accidentally "raise" the priority either)
-			if (!gViewerWindow->getActive() /* viewer window minimized? */
-				&& new_priority > LLPluginClassMedia::PRIORITY_HIDDEN)
-			{
-				new_priority = LLPluginClassMedia::PRIORITY_HIDDEN;
-			}
-			else if (!gFocusMgr.getAppHasFocus() /* viewer window lost focus? */
-					 && new_priority > LLPluginClassMedia::PRIORITY_LOW)
-			{
-				new_priority = LLPluginClassMedia::PRIORITY_LOW;
-			}
-
-			if(!inworld_media_enabled)
-			{
-				// If inworld media is locked out, force all inworld media to stay unloaded.
-				if(!pimpl->getUsedInUI())
-				{
-					new_priority = LLPluginClassMedia::PRIORITY_UNLOADED;
-				}
-			}
-			// update the audio stream here as well
-			static bool restore_parcel_audio = false;
-			if( !inworld_audio_enabled)
-			{
-				if(LLViewerMedia::isParcelAudioPlaying() && gAudiop && LLViewerMedia::hasParcelAudio())
-				{
-					LLViewerAudio::getInstance()->stopInternetStreamWithAutoFade();
-					restore_parcel_audio = true;
-				}
-			}
+        for(; iter != end; iter++)
+        {
+            LLViewerMediaImpl* pimpl = *iter;
+
+            LLPluginClassMedia::EPriority new_priority = LLPluginClassMedia::PRIORITY_NORMAL;
+
+            if(pimpl->isForcedUnloaded() || (impl_count_total >= (int)max_instances))
+            {
+                // Never load muted or failed impls.
+                // Hard limit on the number of instances that will be loaded at one time
+                new_priority = LLPluginClassMedia::PRIORITY_UNLOADED;
+            }
+            else if(!pimpl->getVisible())
+            {
+                new_priority = LLPluginClassMedia::PRIORITY_HIDDEN;
+            }
+            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 if(pimpl->isParcelMedia())
+            {
+                new_priority = LLPluginClassMedia::PRIORITY_NORMAL;
+                impl_count_interest_normal++;
+            }
+            else
+            {
+                // Look at interest and CPU usage for instances that aren't in any of the above states.
+
+                // 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 = 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)
+                {
+                    // This media is completely invisible, due to being outside the view frustrum or out of range.
+                    new_priority = LLPluginClassMedia::PRIORITY_HIDDEN;
+                }
+                else if(check_cpu_usage && (total_cpu > max_cpu))
+                {
+                    // Higher priority plugins have already used up the CPU budget.  Set remaining ones to slideshow priority.
+                    new_priority = LLPluginClassMedia::PRIORITY_SLIDESHOW;
+                }
+                else if((impl_count_interest_normal < (int)max_normal) && !media_is_small)
+                {
+                    // Up to max_normal inworld get normal priority
+                    new_priority = LLPluginClassMedia::PRIORITY_NORMAL;
+                    impl_count_interest_normal++;
+                }
+                else if (impl_count_interest_low + impl_count_interest_normal < (int)max_low + (int)max_normal)
+                {
+                    // The next max_low inworld get turned down
+                    new_priority = LLPluginClassMedia::PRIORITY_LOW;
+                    impl_count_interest_low++;
+
+                    // Set the low priority size for downsampling to approximately the size the texture is displayed at.
+                    {
+                        F32 approximate_interest_dimension = (F32) sqrt(pimpl->getInterest());
+
+                        pimpl->setLowPrioritySizeLimit(ll_round(approximate_interest_dimension));
+                    }
+                }
+                else
+                {
+                    // Any additional impls (up to max_instances) get very infrequent time
+                    new_priority = LLPluginClassMedia::PRIORITY_SLIDESHOW;
+                }
+            }
+
+            if(!pimpl->getUsedInUI() && (new_priority != LLPluginClassMedia::PRIORITY_UNLOADED))
+            {
+                // This is a loadable inworld impl -- the last one in the list in this class defines the lowest loadable interest.
+                lowest_interest_loadable = pimpl;
+
+                impl_count_total++;
+            }
+
+            // Overrides if the window is minimized or we lost focus (taking care
+            // not to accidentally "raise" the priority either)
+            if (!gViewerWindow->getActive() /* viewer window minimized? */
+                && new_priority > LLPluginClassMedia::PRIORITY_HIDDEN)
+            {
+                new_priority = LLPluginClassMedia::PRIORITY_HIDDEN;
+            }
+            else if (!gFocusMgr.getAppHasFocus() /* viewer window lost focus? */
+                     && new_priority > LLPluginClassMedia::PRIORITY_LOW)
+            {
+                new_priority = LLPluginClassMedia::PRIORITY_LOW;
+            }
+
+            if(!inworld_media_enabled)
+            {
+                // If inworld media is locked out, force all inworld media to stay unloaded.
+                if(!pimpl->getUsedInUI())
+                {
+                    new_priority = LLPluginClassMedia::PRIORITY_UNLOADED;
+                }
+            }
+            // update the audio stream here as well
+            static bool restore_parcel_audio = false;
+            if( !inworld_audio_enabled)
+            {
+                if(LLViewerMedia::isParcelAudioPlaying() && gAudiop && LLViewerMedia::hasParcelAudio())
+                {
+                    LLViewerAudio::getInstance()->stopInternetStreamWithAutoFade();
+                    restore_parcel_audio = true;
+                }
+            }
             else
             {
                 if(gAudiop && LLViewerMedia::hasParcelAudio() && restore_parcel_audio && gSavedSettings.getBOOL("MediaTentativeAutoPlay"))
@@ -836,76 +836,76 @@ void LLViewerMedia::updateMedia(void *dummy_arg)
                 }
             }
 
-			pimpl->setPriority(new_priority);
-
-			if(pimpl->getUsedInUI())
-			{
-				// Any impls used in the UI should not be in the proximity list.
-				pimpl->mProximity = -1;
-			}
-			else
-			{
-				proximity_order.push_back(pimpl);
-			}
-
-			total_cpu += pimpl->getCPUUsage();
-
-			if (!pimpl->getUsedInUI() && pimpl->hasMedia())
-			{
-				mAnyMediaShowing = true;
-			}
-
-			if (!pimpl->getUsedInUI() && pimpl->hasMedia() && (pimpl->isMediaPlaying() || !pimpl->isMediaTimeBased()))
-			{
-				// consider visible non-timebased media as playing
-				mAnyMediaPlaying = true;
-			}
-
-		}
-	}
-
-	// Re-calculate this every time.
-	sLowestLoadableImplInterest	= 0.0f;
-
-	// Only do this calculation if we've hit the impl count limit -- up until that point we always need to load media data.
-	if(lowest_interest_loadable && (impl_count_total >= (int)max_instances))
-	{
-		// Get the interest value of this impl's object for use by isInterestingEnough
-		LLVOVolume *object = lowest_interest_loadable->getSomeObject();
-		if(object)
-		{
-			// NOTE: Don't use getMediaInterest() here.  We want the pixel area, not the total media interest,
-			// 		so that we match up with the calculation done in LLMediaDataClient.
-			sLowestLoadableImplInterest = object->getPixelArea();
-		}
-	}
-
-	if(gSavedSettings.getBOOL("MediaPerformanceManagerDebug"))
-	{
-		// Give impls the same ordering as the priority list
-		// they're already in the right order for this.
-	}
-	else
-	{
+            pimpl->setPriority(new_priority);
+
+            if(pimpl->getUsedInUI())
+            {
+                // Any impls used in the UI should not be in the proximity list.
+                pimpl->mProximity = -1;
+            }
+            else
+            {
+                proximity_order.push_back(pimpl);
+            }
+
+            total_cpu += pimpl->getCPUUsage();
+
+            if (!pimpl->getUsedInUI() && pimpl->hasMedia())
+            {
+                mAnyMediaShowing = true;
+            }
+
+            if (!pimpl->getUsedInUI() && pimpl->hasMedia() && (pimpl->isMediaPlaying() || !pimpl->isMediaTimeBased()))
+            {
+                // consider visible non-timebased media as playing
+                mAnyMediaPlaying = true;
+            }
+
+        }
+    }
+
+    // Re-calculate this every time.
+    sLowestLoadableImplInterest = 0.0f;
+
+    // Only do this calculation if we've hit the impl count limit -- up until that point we always need to load media data.
+    if(lowest_interest_loadable && (impl_count_total >= (int)max_instances))
+    {
+        // Get the interest value of this impl's object for use by isInterestingEnough
+        LLVOVolume *object = lowest_interest_loadable->getSomeObject();
+        if(object)
+        {
+            // NOTE: Don't use getMediaInterest() here.  We want the pixel area, not the total media interest,
+            //      so that we match up with the calculation done in LLMediaDataClient.
+            sLowestLoadableImplInterest = object->getPixelArea();
+        }
+    }
+
+    if(gSavedSettings.getBOOL("MediaPerformanceManagerDebug"))
+    {
+        // Give impls the same ordering as the priority list
+        // they're already in the right order for this.
+    }
+    else
+    {
         LL_PROFILE_ZONE_NAMED_CATEGORY_MEDIA("media sort2"); // LL_RECORD_BLOCK_TIME(FTM_MEDIA_SORT2);
-		// Use a distance-based sort for proximity values.
-		std::stable_sort(proximity_order.begin(), proximity_order.end(), proximity_comparitor);
-	}
+        // 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;
-	}
+    // 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 << LL_ENDL;
+    LL_DEBUGS("PluginPriority") << "Total reported CPU usage is " << total_cpu << LL_ENDL;
 
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMedia::isAnyMediaShowing()
 {
-	return mAnyMediaShowing;
+    return mAnyMediaShowing;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -917,56 +917,56 @@ bool LLViewerMedia::isAnyMediaPlaying()
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMedia::setAllMediaEnabled(bool val)
 {
-	// Set "tentative" autoplay first.  We need to do this here or else
-	// re-enabling won't start up the media below.
-	gSavedSettings.setBOOL("MediaTentativeAutoPlay", val);
-
-	// Then
-	impl_list::iterator iter = sViewerMediaImplList.begin();
-	impl_list::iterator end = sViewerMediaImplList.end();
-
-	for(; iter != end; iter++)
-	{
-		LLViewerMediaImpl* pimpl = *iter;
-		if (!pimpl->getUsedInUI())
-		{
-			pimpl->setDisabled(!val);
-		}
-	}
-
-	// Also do Parcel Media and Parcel Audio
-	if (val)
-	{
-		if (!LLViewerMedia::isParcelMediaPlaying() && LLViewerMedia::hasParcelMedia())
-		{
-			LLViewerParcelMedia::getInstance()->play(LLViewerParcelMgr::getInstance()->getAgentParcel());
-		}
-
-		static LLCachedControl<bool> audio_streaming_music(gSavedSettings, "AudioStreamingMusic", true);
-		if (audio_streaming_music &&
-			!LLViewerMedia::isParcelAudioPlaying() &&
-			gAudiop &&
-			LLViewerMedia::hasParcelAudio())
-		{
-			if (LLAudioEngine::AUDIO_PAUSED == gAudiop->isInternetStreamPlaying())
-			{
-				// 'false' means unpause
-				gAudiop->pauseInternetStream(false);
-			}
-			else
-			{
-				LLViewerAudio::getInstance()->startInternetStreamWithAutoFade(LLViewerMedia::getParcelAudioURL());
-			}
-		}
-	}
-	else {
-		// This actually unloads the impl, as opposed to "stop"ping the media
-		LLViewerParcelMedia::getInstance()->stop();
-		if (gAudiop)
-		{
-			LLViewerAudio::getInstance()->stopInternetStreamWithAutoFade();
-		}
-	}
+    // Set "tentative" autoplay first.  We need to do this here or else
+    // re-enabling won't start up the media below.
+    gSavedSettings.setBOOL("MediaTentativeAutoPlay", val);
+
+    // Then
+    impl_list::iterator iter = sViewerMediaImplList.begin();
+    impl_list::iterator end = sViewerMediaImplList.end();
+
+    for(; iter != end; iter++)
+    {
+        LLViewerMediaImpl* pimpl = *iter;
+        if (!pimpl->getUsedInUI())
+        {
+            pimpl->setDisabled(!val);
+        }
+    }
+
+    // Also do Parcel Media and Parcel Audio
+    if (val)
+    {
+        if (!LLViewerMedia::isParcelMediaPlaying() && LLViewerMedia::hasParcelMedia())
+        {
+            LLViewerParcelMedia::getInstance()->play(LLViewerParcelMgr::getInstance()->getAgentParcel());
+        }
+
+        static LLCachedControl<bool> audio_streaming_music(gSavedSettings, "AudioStreamingMusic", true);
+        if (audio_streaming_music &&
+            !LLViewerMedia::isParcelAudioPlaying() &&
+            gAudiop &&
+            LLViewerMedia::hasParcelAudio())
+        {
+            if (LLAudioEngine::AUDIO_PAUSED == gAudiop->isInternetStreamPlaying())
+            {
+                // 'false' means unpause
+                gAudiop->pauseInternetStream(false);
+            }
+            else
+            {
+                LLViewerAudio::getInstance()->startInternetStreamWithAutoFade(LLViewerMedia::getParcelAudioURL());
+            }
+        }
+    }
+    else {
+        // This actually unloads the impl, as opposed to "stop"ping the media
+        LLViewerParcelMedia::getInstance()->stop();
+        if (gAudiop)
+        {
+            LLViewerAudio::getInstance()->stopInternetStreamWithAutoFade();
+        }
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -1058,7 +1058,7 @@ bool LLViewerMedia::isParcelMediaPlaying()
 /////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMedia::isParcelAudioPlaying()
 {
-	return (LLViewerMedia::hasParcelAudio() && gAudiop && LLAudioEngine::AUDIO_PLAYING == gAudiop->isInternetStreamPlaying());
+    return (LLViewerMedia::hasParcelAudio() && gAudiop && LLAudioEngine::AUDIO_PLAYING == gAudiop->isInternetStreamPlaying());
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
@@ -1070,120 +1070,120 @@ void LLViewerMedia::authSubmitCallback(const LLSD& notification, const LLSD& res
 
 void LLViewerMedia::onAuthSubmit(const LLSD& notification, const LLSD& response)
 {
-	LLViewerMediaImpl *impl = LLViewerMedia::getMediaImplFromTextureID(notification["payload"]["media_id"]);
-	if(impl)
-	{
-		LLPluginClassMedia* media = impl->getMediaPlugin();
-		if(media)
-		{
-			if (response["ok"])
-			{
-				media->sendAuthResponse(true, response["username"], response["password"]);
-			}
-			else
-			{
-				media->sendAuthResponse(false, "", "");
-			}
-		}
-	}
+    LLViewerMediaImpl *impl = LLViewerMedia::getMediaImplFromTextureID(notification["payload"]["media_id"]);
+    if(impl)
+    {
+        LLPluginClassMedia* media = impl->getMediaPlugin();
+        if(media)
+        {
+            if (response["ok"])
+            {
+                media->sendAuthResponse(true, response["username"], response["password"]);
+            }
+            else
+            {
+                media->sendAuthResponse(false, "", "");
+            }
+        }
+    }
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMedia::clearAllCookies()
 {
-	// Clear all cookies for all plugins
-	impl_list::iterator iter = sViewerMediaImplList.begin();
-	impl_list::iterator end = sViewerMediaImplList.end();
-	for (; iter != end; iter++)
-	{
-		LLViewerMediaImpl* pimpl = *iter;
-		if(pimpl->mMediaSource)
-		{
-			pimpl->mMediaSource->clear_cookies();
-		}
-	}
+    // Clear all cookies for all plugins
+    impl_list::iterator iter = sViewerMediaImplList.begin();
+    impl_list::iterator end = sViewerMediaImplList.end();
+    for (; iter != end; iter++)
+    {
+        LLViewerMediaImpl* pimpl = *iter;
+        if(pimpl->mMediaSource)
+        {
+            pimpl->mMediaSource->clear_cookies();
+        }
+    }
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMedia::clearAllCaches()
 {
-	// Clear all plugins' caches
-	impl_list::iterator iter = sViewerMediaImplList.begin();
-	impl_list::iterator end = sViewerMediaImplList.end();
-	for (; iter != end; iter++)
-	{
-		LLViewerMediaImpl* pimpl = *iter;
-		pimpl->clearCache();
-	}
+    // Clear all plugins' caches
+    impl_list::iterator iter = sViewerMediaImplList.begin();
+    impl_list::iterator end = sViewerMediaImplList.end();
+    for (; iter != end; iter++)
+    {
+        LLViewerMediaImpl* pimpl = *iter;
+        pimpl->clearCache();
+    }
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMedia::setCookiesEnabled(bool enabled)
 {
-	// Set the "cookies enabled" flag for all loaded plugins
-	impl_list::iterator iter = sViewerMediaImplList.begin();
-	impl_list::iterator end = sViewerMediaImplList.end();
-	for (; iter != end; iter++)
-	{
-		LLViewerMediaImpl* pimpl = *iter;
-		if(pimpl->mMediaSource)
-		{
-			pimpl->mMediaSource->cookies_enabled(enabled);
-		}
-	}
+    // Set the "cookies enabled" flag for all loaded plugins
+    impl_list::iterator iter = sViewerMediaImplList.begin();
+    impl_list::iterator end = sViewerMediaImplList.end();
+    for (; iter != end; iter++)
+    {
+        LLViewerMediaImpl* pimpl = *iter;
+        if(pimpl->mMediaSource)
+        {
+            pimpl->mMediaSource->cookies_enabled(enabled);
+        }
+    }
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMedia::setProxyConfig(bool enable, const std::string &host, int port)
 {
-	// Set the proxy config for all loaded plugins
-	impl_list::iterator iter = sViewerMediaImplList.begin();
-	impl_list::iterator end = sViewerMediaImplList.end();
-	for (; iter != end; iter++)
-	{
-		LLViewerMediaImpl* pimpl = *iter;
-		if(pimpl->mMediaSource)
-		{
-			pimpl->mMediaSource->proxy_setup(enable, host, port);
-		}
-	}
+    // Set the proxy config for all loaded plugins
+    impl_list::iterator iter = sViewerMediaImplList.begin();
+    impl_list::iterator end = sViewerMediaImplList.end();
+    for (; iter != end; iter++)
+    {
+        LLViewerMediaImpl* pimpl = *iter;
+        if(pimpl->mMediaSource)
+        {
+            pimpl->mMediaSource->proxy_setup(enable, host, port);
+        }
+    }
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
 LLSD LLViewerMedia::getHeaders()
 {
-	LLSD headers = LLSD::emptyMap();
-	headers[HTTP_OUT_HEADER_ACCEPT] = "*/*";
-	// *TODO: Should this be 'application/llsd+xml' ?
-	// *TODO: Should this even be set at all?   This header is only not overridden in 'GET' methods.
-	headers[HTTP_OUT_HEADER_CONTENT_TYPE] = HTTP_CONTENT_XML;
-	headers[HTTP_OUT_HEADER_COOKIE] = mOpenIDCookie;
-	headers[HTTP_OUT_HEADER_USER_AGENT] = getCurrentUserAgent();
+    LLSD headers = LLSD::emptyMap();
+    headers[HTTP_OUT_HEADER_ACCEPT] = "*/*";
+    // *TODO: Should this be 'application/llsd+xml' ?
+    // *TODO: Should this even be set at all?   This header is only not overridden in 'GET' methods.
+    headers[HTTP_OUT_HEADER_CONTENT_TYPE] = HTTP_CONTENT_XML;
+    headers[HTTP_OUT_HEADER_COOKIE] = mOpenIDCookie;
+    headers[HTTP_OUT_HEADER_USER_AGENT] = getCurrentUserAgent();
 
-	return headers;
+    return headers;
 }
 
  /////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMedia::parseRawCookie(const std::string raw_cookie, std::string& name, std::string& value, std::string& path, bool& httponly, bool& secure)
 {
-	std::size_t name_pos = raw_cookie.find_first_of("=");
-	if (name_pos != std::string::npos)
-	{
-		name = raw_cookie.substr(0, name_pos);
-		std::size_t value_pos = raw_cookie.find_first_of(";", name_pos);
-		if (value_pos != std::string::npos)
-		{
-			value = raw_cookie.substr(name_pos + 1, value_pos - name_pos - 1);
-			path = "/";	// assume root path for now
+    std::size_t name_pos = raw_cookie.find_first_of("=");
+    if (name_pos != std::string::npos)
+    {
+        name = raw_cookie.substr(0, name_pos);
+        std::size_t value_pos = raw_cookie.find_first_of(";", name_pos);
+        if (value_pos != std::string::npos)
+        {
+            value = raw_cookie.substr(name_pos + 1, value_pos - name_pos - 1);
+            path = "/"; // assume root path for now
 
-			httponly = true;	// hard coded for now
-			secure = true;
+            httponly = true;    // hard coded for now
+            secure = true;
 
-			return true;
-		}
-	}
+            return true;
+        }
+    }
 
-	return false;
+    return false;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
@@ -1203,13 +1203,13 @@ LLCore::HttpHeaders::ptr_t LLViewerMedia::getHttpHeaders()
 /////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMedia::setOpenIDCookie(const std::string& url)
 {
-	if(!gNonInteractive && !mOpenIDCookie.empty())
-	{
+    if(!gNonInteractive && !mOpenIDCookie.empty())
+    {
         std::string profileUrl = getProfileURL("");
 
         LLCoros::instance().launch("LLViewerMedia::getOpenIDCookieCoro",
             boost::bind(&LLViewerMedia::getOpenIDCookieCoro, profileUrl));
-	}
+    }
 }
 
 //static
@@ -1221,7 +1221,7 @@ void LLViewerMedia::getOpenIDCookieCoro(std::string url)
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
     LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
     LLCore::HttpHeaders::ptr_t httpHeaders(new LLCore::HttpHeaders);
-    
+
     httpOpts->setFollowRedirects(true);
     httpOpts->setWantHeaders(true);
     httpOpts->setSSLVerifyPeer(false); // viewer's cert bundle doesn't appear to agree with web certs from "https://my.secondlife.com/"
@@ -1229,7 +1229,7 @@ void LLViewerMedia::getOpenIDCookieCoro(std::string url)
     LLURL hostUrl(url.c_str());
     std::string hostAuth = hostUrl.getAuthority();
 
-    // *TODO: Expand LLURL to split and extract this information better. 
+    // *TODO: Expand LLURL to split and extract this information better.
     // The structure of a URL is well defined and needing to retrieve parts of it are common.
     // original comment:
     // The LLURL can give me the 'authority', which is of the form: [username[:password]@]hostname[:port]
@@ -1242,8 +1242,8 @@ void LLViewerMedia::getOpenIDCookieCoro(std::string url)
         hostStart = 0;
     }
     else
-    {   // Hostname starts after the @. 
-			// Hostname starts after the @. 
+    {   // Hostname starts after the @.
+            // Hostname starts after the @.
         // (If the hostname part is empty, this may put host_start at the end of the string.  In that case, it will end up passing through an empty hostname, which is correct.)
         ++hostStart;
     }
@@ -1252,54 +1252,54 @@ void LLViewerMedia::getOpenIDCookieCoro(std::string url)
     {   // no port
         hostEnd = authority.size();
     }
-    
-	LLViewerMedia* inst = getInstance();
-	if (url.length())
-	{
-		LLMediaCtrl* media_instance = LLFloaterReg::getInstance("destinations")->getChild<LLMediaCtrl>("destination_guide_contents");
-		if (media_instance)
-		{
-			std::string cookie_host = authority.substr(hostStart, hostEnd - hostStart);
-			std::string cookie_name = "";
-			std::string cookie_value = "";
-			std::string cookie_path = "";
-			bool httponly = true;
-			bool secure = true;
-			if (inst->parseRawCookie(inst->mOpenIDCookie, cookie_name, cookie_value, cookie_path, httponly, secure) &&
-				media_instance->getMediaPlugin())
-			{
-				// MAINT-5711 - inexplicably, the CEF setCookie function will no longer set the cookie if the 
-				// url and domain are not the same. This used to be my.sl.com and id.sl.com respectively and worked.
-				// For now, we use the URL for the OpenID POST request since it will have the same authority
-				// as the domain field.
-				// (Feels like there must be a less dirty way to construct a URL from component LLURL parts)
-				// MAINT-6392 - Rider: Do not change, however, the original URI requested, since it is used further
-				// down.
-				std::string cefUrl(std::string(inst->mOpenIDURL.mURI) + "://" + std::string(inst->mOpenIDURL.mAuthority));
-
-				media_instance->getMediaPlugin()->setCookie(cefUrl, cookie_name, cookie_value, cookie_host, 
+
+    LLViewerMedia* inst = getInstance();
+    if (url.length())
+    {
+        LLMediaCtrl* media_instance = LLFloaterReg::getInstance("destinations")->getChild<LLMediaCtrl>("destination_guide_contents");
+        if (media_instance)
+        {
+            std::string cookie_host = authority.substr(hostStart, hostEnd - hostStart);
+            std::string cookie_name = "";
+            std::string cookie_value = "";
+            std::string cookie_path = "";
+            bool httponly = true;
+            bool secure = true;
+            if (inst->parseRawCookie(inst->mOpenIDCookie, cookie_name, cookie_value, cookie_path, httponly, secure) &&
+                media_instance->getMediaPlugin())
+            {
+                // MAINT-5711 - inexplicably, the CEF setCookie function will no longer set the cookie if the
+                // url and domain are not the same. This used to be my.sl.com and id.sl.com respectively and worked.
+                // For now, we use the URL for the OpenID POST request since it will have the same authority
+                // as the domain field.
+                // (Feels like there must be a less dirty way to construct a URL from component LLURL parts)
+                // MAINT-6392 - Rider: Do not change, however, the original URI requested, since it is used further
+                // down.
+                std::string cefUrl(std::string(inst->mOpenIDURL.mURI) + "://" + std::string(inst->mOpenIDURL.mAuthority));
+
+                media_instance->getMediaPlugin()->setCookie(cefUrl, cookie_name, cookie_value, cookie_host,
                     cookie_path, httponly, secure);
 
                 // Now that we have parsed the raw cookie, we must store it so that each new media instance
                 // can also get a copy and faciliate logging into internal SL sites.
-				media_instance->getMediaPlugin()->storeOpenIDCookie(cefUrl, cookie_name, cookie_value, 
+                media_instance->getMediaPlugin()->storeOpenIDCookie(cefUrl, cookie_name, cookie_value,
                     cookie_host, cookie_path, httponly, secure);
-			}
-		}
-	}
+            }
+        }
+    }
 
-    // Note: Rider: MAINT-6392 - Some viewer code requires access to the my.sl.com openid cookie for such 
-    // actions as posting snapshots to the feed.  This is handled through HTTPCore rather than CEF and so 
+    // Note: Rider: MAINT-6392 - Some viewer code requires access to the my.sl.com openid cookie for such
+    // actions as posting snapshots to the feed.  This is handled through HTTPCore rather than CEF and so
     // we must learn to SHARE the cookies.
 
-	// Do a web profile get so we can store the cookie 
+    // Do a web profile get so we can store the cookie
     httpHeaders->append(HTTP_OUT_HEADER_ACCEPT, "*/*");
     httpHeaders->append(HTTP_OUT_HEADER_COOKIE, inst->mOpenIDCookie);
     httpHeaders->append(HTTP_OUT_HEADER_USER_AGENT, inst->getCurrentUserAgent());
 
     LL_DEBUGS("MediaAuth") << "Requesting " << url << LL_ENDL;
     LL_DEBUGS("MediaAuth") << "sOpenIDCookie = [" << inst->mOpenIDCookie << "]" << LL_ENDL;
-    
+
     LLSD result = httpAdapter->getRawAndSuspend(httpRequest, url, httpOpts, httpHeaders);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
@@ -1329,7 +1329,7 @@ void LLViewerMedia::getOpenIDCookieCoro(std::string url)
 /////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMedia::openIDSetup(const std::string &openidUrl, const std::string &openidToken)
 {
-	LL_DEBUGS("MediaAuth") << "url = \"" << openidUrl << "\", token = \"" << openidToken << "\"" << LL_ENDL;
+    LL_DEBUGS("MediaAuth") << "url = \"" << openidUrl << "\", token = \"" << openidToken << "\"" << LL_ENDL;
 
     LLCoros::instance().launch("LLViewerMedia::openIDSetupCoro",
         boost::bind(&LLViewerMedia::openIDSetupCoro, openidUrl, openidToken));
@@ -1346,11 +1346,11 @@ void LLViewerMedia::openIDSetupCoro(std::string openidUrl, std::string openidTok
 
     httpOpts->setWantHeaders(true);
 
-	// post the token to the url 
+    // post the token to the url
     // the responder will need to extract the cookie(s).
     // Save the OpenID URL for later -- we may need the host when adding the cookie.
     getInstance()->mOpenIDURL.init(openidUrl.c_str());
-	
+
     // We shouldn't ever do this twice, but just in case this code gets repurposed later, clear existing cookies.
     getInstance()->mOpenIDCookie.clear();
 
@@ -1383,200 +1383,200 @@ void LLViewerMedia::openIDSetupCoro(std::string openidUrl, std::string openidTok
     // We don't care about the content of the response, only the Set-Cookie header.
     const std::string& cookie = resultHeaders[HTTP_IN_HEADER_SET_COOKIE].asString();
 
-	// *TODO: What about bad status codes?  Does this destroy previous cookies?
+    // *TODO: What about bad status codes?  Does this destroy previous cookies?
     LLViewerMedia::getInstance()->openIDCookieResponse(openidUrl, cookie);
     LL_DEBUGS("MediaAuth") << "OpenID cookie set." << LL_ENDL;
-			
+
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMedia::openIDCookieResponse(const std::string& url, const std::string &cookie)
 {
-	LL_DEBUGS("MediaAuth") << "Cookie received: \"" << cookie << "\"" << LL_ENDL;
+    LL_DEBUGS("MediaAuth") << "Cookie received: \"" << cookie << "\"" << LL_ENDL;
 
-	mOpenIDCookie += cookie;
+    mOpenIDCookie += cookie;
 
-	setOpenIDCookie(url);
+    setOpenIDCookie(url);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMedia::proxyWindowOpened(const std::string &target, const std::string &uuid)
 {
-	if(uuid.empty())
-		return;
+    if(uuid.empty())
+        return;
 
-	for (impl_list::iterator iter = sViewerMediaImplList.begin(); iter != sViewerMediaImplList.end(); iter++)
-	{
-		if((*iter)->mMediaSource && (*iter)->mMediaSource->pluginSupportsMediaBrowser())
-		{
-			(*iter)->mMediaSource->proxyWindowOpened(target, uuid);
-		}
-	}
+    for (impl_list::iterator iter = sViewerMediaImplList.begin(); iter != sViewerMediaImplList.end(); iter++)
+    {
+        if((*iter)->mMediaSource && (*iter)->mMediaSource->pluginSupportsMediaBrowser())
+        {
+            (*iter)->mMediaSource->proxyWindowOpened(target, uuid);
+        }
+    }
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMedia::proxyWindowClosed(const std::string &uuid)
 {
-	if(uuid.empty())
-		return;
+    if(uuid.empty())
+        return;
 
-	for (impl_list::iterator iter = sViewerMediaImplList.begin(); iter != sViewerMediaImplList.end(); iter++)
-	{
-		if((*iter)->mMediaSource && (*iter)->mMediaSource->pluginSupportsMediaBrowser())
-		{
-			(*iter)->mMediaSource->proxyWindowClosed(uuid);
-		}
-	}
+    for (impl_list::iterator iter = sViewerMediaImplList.begin(); iter != sViewerMediaImplList.end(); iter++)
+    {
+        if((*iter)->mMediaSource && (*iter)->mMediaSource->pluginSupportsMediaBrowser())
+        {
+            (*iter)->mMediaSource->proxyWindowClosed(uuid);
+        }
+    }
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMedia::createSpareBrowserMediaSource()
 {
-	// If we don't have a spare browser media source, create one.
-	// However, if PluginAttachDebuggerToPlugins is set then don't spawn a spare
-	// SLPlugin process in order to not be confused by an unrelated gdb terminal
-	// popping up at the moment we start a media plugin.
-	if (!mSpareBrowserMediaSource && !gSavedSettings.getBOOL("PluginAttachDebuggerToPlugins"))
-	{
-		// The null owner will keep the browser plugin from fully initializing
-		// (specifically, it keeps LLPluginClassMedia from negotiating a size change,
-		// which keeps MediaPluginWebkit::initBrowserWindow from doing anything until we have some necessary data, like the background color)
-		mSpareBrowserMediaSource = LLViewerMediaImpl::newSourceFromMediaType(HTTP_CONTENT_TEXT_HTML, NULL, 0, 0, 1.0);
-	}
+    // If we don't have a spare browser media source, create one.
+    // However, if PluginAttachDebuggerToPlugins is set then don't spawn a spare
+    // SLPlugin process in order to not be confused by an unrelated gdb terminal
+    // popping up at the moment we start a media plugin.
+    if (!mSpareBrowserMediaSource && !gSavedSettings.getBOOL("PluginAttachDebuggerToPlugins"))
+    {
+        // The null owner will keep the browser plugin from fully initializing
+        // (specifically, it keeps LLPluginClassMedia from negotiating a size change,
+        // which keeps MediaPluginWebkit::initBrowserWindow from doing anything until we have some necessary data, like the background color)
+        mSpareBrowserMediaSource = LLViewerMediaImpl::newSourceFromMediaType(HTTP_CONTENT_TEXT_HTML, NULL, 0, 0, 1.0);
+    }
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
 LLPluginClassMedia* LLViewerMedia::getSpareBrowserMediaSource()
 {
-	LLPluginClassMedia* result = mSpareBrowserMediaSource;
-	mSpareBrowserMediaSource = NULL;
-	return result;
+    LLPluginClassMedia* result = mSpareBrowserMediaSource;
+    mSpareBrowserMediaSource = NULL;
+    return result;
 };
 
 bool LLViewerMedia::hasInWorldMedia()
 {
-	impl_list::iterator iter = sViewerMediaImplList.begin();
-	impl_list::iterator end = sViewerMediaImplList.end();
-	// This should be quick, because there should be very few non-in-world-media impls
-	for (; iter != end; iter++)
-	{
-		LLViewerMediaImpl* pimpl = *iter;
-		if (!pimpl->getUsedInUI() && !pimpl->isParcelMedia())
-		{
-			// Found an in-world media impl
-			return true;
-		}
-	}
-	return false;
+    impl_list::iterator iter = sViewerMediaImplList.begin();
+    impl_list::iterator end = sViewerMediaImplList.end();
+    // This should be quick, because there should be very few non-in-world-media impls
+    for (; iter != end; iter++)
+    {
+        LLViewerMediaImpl* pimpl = *iter;
+        if (!pimpl->getUsedInUI() && !pimpl->isParcelMedia())
+        {
+            // Found an in-world media impl
+            return true;
+        }
+    }
+    return false;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMedia::hasParcelMedia()
 {
-	return !LLViewerParcelMedia::getInstance()->getURL().empty();
+    return !LLViewerParcelMedia::getInstance()->getURL().empty();
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMedia::hasParcelAudio()
 {
-	return !LLViewerMedia::getParcelAudioURL().empty();
+    return !LLViewerMedia::getParcelAudioURL().empty();
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 std::string LLViewerMedia::getParcelAudioURL()
 {
-	return LLViewerParcelMgr::getInstance()->getAgentParcel()->getMusicURL();
+    return LLViewerParcelMgr::getInstance()->getAgentParcel()->getMusicURL();
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMedia::onTeleportFinished()
 {
-	// On teleport, clear this setting (i.e. set it to true)
-	gSavedSettings.setBOOL("MediaTentativeAutoPlay", true);
+    // On teleport, clear this setting (i.e. set it to true)
+    gSavedSettings.setBOOL("MediaTentativeAutoPlay", true);
 
-	LLViewerMediaImpl::sMimeTypesFailed.clear();
+    LLViewerMediaImpl::sMimeTypesFailed.clear();
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMedia::setOnlyAudibleMediaTextureID(const LLUUID& texture_id)
 {
-	sOnlyAudibleTextureID = texture_id;
-	sForceUpdate = true;
+    sOnlyAudibleTextureID = texture_id;
+    sForceUpdate = true;
 }
 
 std::vector<std::string> LLViewerMediaImpl::sMimeTypesFailed;
 //////////////////////////////////////////////////////////////////////////////////////////
 // LLViewerMediaImpl
 //////////////////////////////////////////////////////////////////////////////////////////
-LLViewerMediaImpl::LLViewerMediaImpl(	  const LLUUID& texture_id,
-										  S32 media_width,
-										  S32 media_height,
-										  U8 media_auto_scale,
-										  U8 media_loop)
+LLViewerMediaImpl::LLViewerMediaImpl(     const LLUUID& texture_id,
+                                          S32 media_width,
+                                          S32 media_height,
+                                          U8 media_auto_scale,
+                                          U8 media_loop)
 :
-	mMediaSource( NULL ),
-	mMovieImageHasMips(false),
-	mMediaWidth(media_width),
-	mMediaHeight(media_height),
-	mMediaAutoScale(media_auto_scale),
-	mMediaLoop(media_loop),
-	mNeedsNewTexture(true),
-	mTextureUsedWidth(0),
-	mTextureUsedHeight(0),
-	mSuspendUpdates(false),
-	mVisible(true),
-	mLastSetCursor( UI_CURSOR_ARROW ),
-	mMediaNavState( MEDIANAVSTATE_NONE ),
-	mInterest(0.0f),
-	mUsedInUI(false),
-	mHasFocus(false),
-	mPriority(LLPluginClassMedia::PRIORITY_UNLOADED),
-	mNavigateRediscoverType(false),
-	mNavigateServerRequest(false),
-	mMediaSourceFailed(false),
-	mRequestedVolume(1.0f),
-	mPreviousVolume(1.0f),
-	mIsMuted(false),
-	mNeedsMuteCheck(false),
-	mPreviousMediaState(MEDIA_NONE),
-	mPreviousMediaTime(0.0f),
-	mIsDisabled(false),
-	mIsParcelMedia(false),
-	mProximity(-1),
-	mProximityDistance(0.0f),
-	mMediaAutoPlay(false),
-	mInNearbyMediaList(false),
-	mClearCache(false),
-	mBackgroundColor(LLColor4::white),
-	mNavigateSuspended(false),
-	mNavigateSuspendedDeferred(false),
-	mIsUpdated(false),
-	mTrustedBrowser(false),
-	mZoomFactor(1.0),
+    mMediaSource( NULL ),
+    mMovieImageHasMips(false),
+    mMediaWidth(media_width),
+    mMediaHeight(media_height),
+    mMediaAutoScale(media_auto_scale),
+    mMediaLoop(media_loop),
+    mNeedsNewTexture(true),
+    mTextureUsedWidth(0),
+    mTextureUsedHeight(0),
+    mSuspendUpdates(false),
+    mVisible(true),
+    mLastSetCursor( UI_CURSOR_ARROW ),
+    mMediaNavState( MEDIANAVSTATE_NONE ),
+    mInterest(0.0f),
+    mUsedInUI(false),
+    mHasFocus(false),
+    mPriority(LLPluginClassMedia::PRIORITY_UNLOADED),
+    mNavigateRediscoverType(false),
+    mNavigateServerRequest(false),
+    mMediaSourceFailed(false),
+    mRequestedVolume(1.0f),
+    mPreviousVolume(1.0f),
+    mIsMuted(false),
+    mNeedsMuteCheck(false),
+    mPreviousMediaState(MEDIA_NONE),
+    mPreviousMediaTime(0.0f),
+    mIsDisabled(false),
+    mIsParcelMedia(false),
+    mProximity(-1),
+    mProximityDistance(0.0f),
+    mMediaAutoPlay(false),
+    mInNearbyMediaList(false),
+    mClearCache(false),
+    mBackgroundColor(LLColor4::white),
+    mNavigateSuspended(false),
+    mNavigateSuspendedDeferred(false),
+    mIsUpdated(false),
+    mTrustedBrowser(false),
+    mZoomFactor(1.0),
     mCleanBrowser(false),
     mMimeProbe(),
     mCanceling(false)
 {
 
-	// Set up the mute list observer if it hasn't been set up already.
-	if(!sViewerMediaMuteListObserverInitialized)
-	{
-		LLMuteList::getInstance()->addObserver(&sViewerMediaMuteListObserver);
-		sViewerMediaMuteListObserverInitialized = true;
-	}
+    // Set up the mute list observer if it hasn't been set up already.
+    if(!sViewerMediaMuteListObserverInitialized)
+    {
+        LLMuteList::getInstance()->addObserver(&sViewerMediaMuteListObserver);
+        sViewerMediaMuteListObserverInitialized = true;
+    }
 
-	add_media_impl(this);
+    add_media_impl(this);
 
-	setTextureID(texture_id);
+    setTextureID(texture_id);
 
-	// connect this media_impl to the media texture, creating it if it doesn't exist.0
-	// This is necessary because we need to be able to use getMaxVirtualSize() even if the media plugin is not loaded.
+    // connect this media_impl to the media texture, creating it if it doesn't exist.0
+    // This is necessary because we need to be able to use getMaxVirtualSize() even if the media plugin is not loaded.
     // *TODO: Consider enabling mipmaps (they have been disabled for a long time). Likely has a significant performance impact for tiled/high texture repeat media. Mip generation in a shader may also be an option if necessary.
-	LLViewerMediaTexture* media_tex = LLViewerTextureManager::getMediaTexture(mTextureId, USE_MIPMAPS);
-	if(media_tex)
-	{
-		media_tex->setMediaImpl();
-	}
+    LLViewerMediaTexture* media_tex = LLViewerTextureManager::getMediaTexture(mTextureId, USE_MIPMAPS);
+    if(media_tex)
+    {
+        media_tex->setMediaImpl();
+    }
 
     mMainQueue = LL::WorkQueue::getInstance("mainloop");
     mTexUpdateQueue = LL::WorkQueue::getInstance("LLImageGL"); // Share work queue with tex loader.
@@ -1585,86 +1585,86 @@ LLViewerMediaImpl::LLViewerMediaImpl(	  const LLUUID& texture_id,
 //////////////////////////////////////////////////////////////////////////////////////////
 LLViewerMediaImpl::~LLViewerMediaImpl()
 {
-	destroyMediaSource();
+    destroyMediaSource();
 
-	LLViewerMediaTexture::removeMediaImplFromTexture(mTextureId) ;
+    LLViewerMediaTexture::removeMediaImplFromTexture(mTextureId) ;
 
-	setTextureID();
-	remove_media_impl(this);
+    setTextureID();
+    remove_media_impl(this);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::emitEvent(LLPluginClassMedia* plugin, LLViewerMediaObserver::EMediaEvent event)
 {
-	// Broadcast to observers using the superclass version
-	LLViewerMediaEventEmitter::emitEvent(plugin, event);
+    // Broadcast to observers using the superclass version
+    LLViewerMediaEventEmitter::emitEvent(plugin, event);
 
-	// If this media is on one or more LLVOVolume objects, tell them about the event as well.
-	std::list< LLVOVolume* >::iterator iter = mObjectList.begin() ;
-	while(iter != mObjectList.end())
-	{
-		LLVOVolume *self = *iter;
-		++iter;
-		self->mediaEvent(this, plugin, event);
-	}
+    // If this media is on one or more LLVOVolume objects, tell them about the event as well.
+    std::list< LLVOVolume* >::iterator iter = mObjectList.begin() ;
+    while(iter != mObjectList.end())
+    {
+        LLVOVolume *self = *iter;
+        ++iter;
+        self->mediaEvent(this, plugin, event);
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMediaImpl::initializeMedia(const std::string& mime_type)
 {
-	bool mimeTypeChanged = (mMimeType != mime_type);
-	bool pluginChanged = (LLMIMETypes::implType(mCurrentMimeType) != LLMIMETypes::implType(mime_type));
+    bool mimeTypeChanged = (mMimeType != mime_type);
+    bool pluginChanged = (LLMIMETypes::implType(mCurrentMimeType) != LLMIMETypes::implType(mime_type));
 
-	if(!mMediaSource || pluginChanged)
-	{
-		// We don't have a plugin at all, or the new mime type is handled by a different plugin than the old mime type.
-		(void)initializePlugin(mime_type);
-	}
-	else if(mimeTypeChanged)
-	{
-		// The same plugin should be able to handle the new media -- just update the stored mime type.
-		mMimeType = mime_type;
-	}
+    if(!mMediaSource || pluginChanged)
+    {
+        // We don't have a plugin at all, or the new mime type is handled by a different plugin than the old mime type.
+        (void)initializePlugin(mime_type);
+    }
+    else if(mimeTypeChanged)
+    {
+        // The same plugin should be able to handle the new media -- just update the stored mime type.
+        mMimeType = mime_type;
+    }
 
-	return (mMediaSource != NULL);
+    return (mMediaSource != NULL);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::createMediaSource()
 {
-	if(mPriority == LLPluginClassMedia::PRIORITY_UNLOADED)
-	{
-		// This media shouldn't be created yet.
-		return;
-	}
+    if(mPriority == LLPluginClassMedia::PRIORITY_UNLOADED)
+    {
+        // This media shouldn't be created yet.
+        return;
+    }
 
-	if(! mMediaURL.empty())
-	{
-		navigateInternal();
-	}
-	else if(! mMimeType.empty())
-	{
-		if (!initializeMedia(mMimeType))
-		{
-			LL_WARNS("Media") << "Failed to initialize media for mime type " << mMimeType << LL_ENDL;
-		}
-	}
+    if(! mMediaURL.empty())
+    {
+        navigateInternal();
+    }
+    else if(! mMimeType.empty())
+    {
+        if (!initializeMedia(mMimeType))
+        {
+            LL_WARNS("Media") << "Failed to initialize media for mime type " << mMimeType << LL_ENDL;
+        }
+    }
 
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::destroyMediaSource()
 {
-	mNeedsNewTexture = true;
+    mNeedsNewTexture = true;
 
-	// Tell the viewer media texture it's no longer active
-	LLViewerMediaTexture* oldImage = LLViewerTextureManager::findMediaTexture( mTextureId );
-	if (oldImage)
-	{
-		oldImage->setPlaying(false) ;
-	}
+    // Tell the viewer media texture it's no longer active
+    LLViewerMediaTexture* oldImage = LLViewerTextureManager::findMediaTexture( mTextureId );
+    if (oldImage)
+    {
+        oldImage->setPlaying(false) ;
+    }
 
-	cancelMimeTypeProbe();
+    cancelMimeTypeProbe();
 
     {
         LLCoros::LockType lock(mLock); // Delay tear-down while bg thread is updating
@@ -1679,215 +1679,215 @@ void LLViewerMediaImpl::destroyMediaSource()
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::setMediaType(const std::string& media_type)
 {
-	mMimeType = media_type;
+    mMimeType = media_type;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 /*static*/
 LLPluginClassMedia* LLViewerMediaImpl::newSourceFromMediaType(std::string media_type, LLPluginClassMediaOwner *owner /* may be NULL */, S32 default_width, S32 default_height, F64 zoom_factor, const std::string target, bool clean_browser)
 {
-	if (gNonInteractive)
+    if (gNonInteractive)
     {
         return NULL;
     }
 
-	std::string plugin_basename = LLMIMETypes::implType(media_type);
-	LLPluginClassMedia* media_source = NULL;
+    std::string plugin_basename = LLMIMETypes::implType(media_type);
+    LLPluginClassMedia* media_source = NULL;
 
-	// HACK: we always try to keep a spare running webkit plugin around to improve launch times.
-	// If a spare was already created before PluginAttachDebuggerToPlugins was set, don't use it.
+    // HACK: we always try to keep a spare running webkit plugin around to improve launch times.
+    // If a spare was already created before PluginAttachDebuggerToPlugins was set, don't use it.
     // Do not use a spare if launching with full viewer control (e.g. Twitter and few others)
-	if ((plugin_basename == "media_plugin_cef") &&
+    if ((plugin_basename == "media_plugin_cef") &&
         !gSavedSettings.getBOOL("PluginAttachDebuggerToPlugins") && !clean_browser)
-	{
-		media_source = LLViewerMedia::getInstance()->getSpareBrowserMediaSource();
-		if(media_source)
-		{
-			media_source->setOwner(owner);
-			media_source->setTarget(target);
-			media_source->setSize(default_width, default_height);
-			media_source->setZoomFactor(zoom_factor);
-
-			return media_source;
-		}
-	}
-	if(plugin_basename.empty())
-	{
-		LL_WARNS_ONCE("Media") << "Couldn't find plugin for media type " << media_type << LL_ENDL;
-	}
-	else
-	{
-		std::string launcher_name = gDirUtilp->getLLPluginLauncher();
-		std::string plugin_name = gDirUtilp->getLLPluginFilename(plugin_basename);
-
-		std::string user_data_path_cache = gDirUtilp->getCacheDir(false);
-		user_data_path_cache += gDirUtilp->getDirDelimiter();
-
-		std::string user_data_path_cef_log = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "cef_log.txt");
-
-		// See if the plugin executable exists
-		llstat s;
-		if(LLFile::stat(launcher_name, &s))
-		{
-			LL_WARNS_ONCE("Media") << "Couldn't find launcher at " << launcher_name << LL_ENDL;
-		}
-		else if(LLFile::stat(plugin_name, &s))
-		{
+    {
+        media_source = LLViewerMedia::getInstance()->getSpareBrowserMediaSource();
+        if(media_source)
+        {
+            media_source->setOwner(owner);
+            media_source->setTarget(target);
+            media_source->setSize(default_width, default_height);
+            media_source->setZoomFactor(zoom_factor);
+
+            return media_source;
+        }
+    }
+    if(plugin_basename.empty())
+    {
+        LL_WARNS_ONCE("Media") << "Couldn't find plugin for media type " << media_type << LL_ENDL;
+    }
+    else
+    {
+        std::string launcher_name = gDirUtilp->getLLPluginLauncher();
+        std::string plugin_name = gDirUtilp->getLLPluginFilename(plugin_basename);
+
+        std::string user_data_path_cache = gDirUtilp->getCacheDir(false);
+        user_data_path_cache += gDirUtilp->getDirDelimiter();
+
+        std::string user_data_path_cef_log = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "cef_log.txt");
+
+        // See if the plugin executable exists
+        llstat s;
+        if(LLFile::stat(launcher_name, &s))
+        {
+            LL_WARNS_ONCE("Media") << "Couldn't find launcher at " << launcher_name << LL_ENDL;
+        }
+        else if(LLFile::stat(plugin_name, &s))
+        {
 #if !LL_LINUX
-			LL_WARNS_ONCE("Media") << "Couldn't find plugin at " << plugin_name << LL_ENDL;
+            LL_WARNS_ONCE("Media") << "Couldn't find plugin at " << plugin_name << LL_ENDL;
 #endif
-		}
-		else
-		{
-			media_source = new LLPluginClassMedia(owner);
-			media_source->setSize(default_width, default_height);
-			media_source->setUserDataPath(user_data_path_cache, gDirUtilp->getUserName(), user_data_path_cef_log);
-			media_source->setLanguageCode(LLUI::getLanguage());
-			media_source->setZoomFactor(zoom_factor);
-
-			// collect 'cookies enabled' setting from prefs and send to embedded browser
-			bool cookies_enabled = gSavedSettings.getBOOL( "CookiesEnabled" );
-			media_source->cookies_enabled( cookies_enabled || clean_browser);
-
-			// collect 'javascript enabled' setting from prefs and send to embedded browser
-			bool javascript_enabled = gSavedSettings.getBOOL("BrowserJavascriptEnabled");
-			media_source->setJavascriptEnabled(javascript_enabled || clean_browser);
-
-			// collect 'web security disabled' (see Chrome --web-security-disabled) setting from prefs and send to embedded browser
-			bool web_security_disabled = gSavedSettings.getBOOL("BrowserWebSecurityDisabled");
-			media_source->setWebSecurityDisabled(web_security_disabled || clean_browser);
-
-			// collect setting indicates if local file access from file URLs is allowed from prefs and send to embedded browser
-			bool file_access_from_file_urls = gSavedSettings.getBOOL("BrowserFileAccessFromFileUrls");
-			media_source->setFileAccessFromFileUrlsEnabled(file_access_from_file_urls || clean_browser);
-
-			// As of SL-15559 PDF files do not load in CEF v91 we enable plugins
-			// but explicitly disable Flash (PDF support in CEF is now treated as a plugin)
-			media_source->setPluginsEnabled(true);
-
-			bool media_plugin_debugging_enabled = gSavedSettings.getBOOL("MediaPluginDebugging");
-			media_source->enableMediaPluginDebugging( media_plugin_debugging_enabled  || clean_browser);
-
-			// need to set agent string here before instance created
-			media_source->setBrowserUserAgent(LLViewerMedia::getInstance()->getCurrentUserAgent());
-
-            // configure and pass proxy setup based on debug settings that are 
+        }
+        else
+        {
+            media_source = new LLPluginClassMedia(owner);
+            media_source->setSize(default_width, default_height);
+            media_source->setUserDataPath(user_data_path_cache, gDirUtilp->getUserName(), user_data_path_cef_log);
+            media_source->setLanguageCode(LLUI::getLanguage());
+            media_source->setZoomFactor(zoom_factor);
+
+            // collect 'cookies enabled' setting from prefs and send to embedded browser
+            bool cookies_enabled = gSavedSettings.getBOOL( "CookiesEnabled" );
+            media_source->cookies_enabled( cookies_enabled || clean_browser);
+
+            // collect 'javascript enabled' setting from prefs and send to embedded browser
+            bool javascript_enabled = gSavedSettings.getBOOL("BrowserJavascriptEnabled");
+            media_source->setJavascriptEnabled(javascript_enabled || clean_browser);
+
+            // collect 'web security disabled' (see Chrome --web-security-disabled) setting from prefs and send to embedded browser
+            bool web_security_disabled = gSavedSettings.getBOOL("BrowserWebSecurityDisabled");
+            media_source->setWebSecurityDisabled(web_security_disabled || clean_browser);
+
+            // collect setting indicates if local file access from file URLs is allowed from prefs and send to embedded browser
+            bool file_access_from_file_urls = gSavedSettings.getBOOL("BrowserFileAccessFromFileUrls");
+            media_source->setFileAccessFromFileUrlsEnabled(file_access_from_file_urls || clean_browser);
+
+            // As of SL-15559 PDF files do not load in CEF v91 we enable plugins
+            // but explicitly disable Flash (PDF support in CEF is now treated as a plugin)
+            media_source->setPluginsEnabled(true);
+
+            bool media_plugin_debugging_enabled = gSavedSettings.getBOOL("MediaPluginDebugging");
+            media_source->enableMediaPluginDebugging( media_plugin_debugging_enabled  || clean_browser);
+
+            // need to set agent string here before instance created
+            media_source->setBrowserUserAgent(LLViewerMedia::getInstance()->getCurrentUserAgent());
+
+            // configure and pass proxy setup based on debug settings that are
             // configured by UI in prefs -> setup
             media_source->proxy_setup(gSavedSettings.getBOOL("BrowserProxyEnabled"), gSavedSettings.getString("BrowserProxyAddress"), gSavedSettings.getS32("BrowserProxyPort"));
 
-			media_source->setTarget(target);
-
-			const std::string plugin_dir = gDirUtilp->getLLPluginDir();
-			if (media_source->init(launcher_name, plugin_dir, plugin_name, gSavedSettings.getBOOL("PluginAttachDebuggerToPlugins")))
-			{
-				return media_source;
-			}
-			else
-			{
-				LL_WARNS("Media") << "Failed to init plugin.  Destroying." << LL_ENDL;
-				delete media_source;
-			}
-		}
-	}
+            media_source->setTarget(target);
+
+            const std::string plugin_dir = gDirUtilp->getLLPluginDir();
+            if (media_source->init(launcher_name, plugin_dir, plugin_name, gSavedSettings.getBOOL("PluginAttachDebuggerToPlugins")))
+            {
+                return media_source;
+            }
+            else
+            {
+                LL_WARNS("Media") << "Failed to init plugin.  Destroying." << LL_ENDL;
+                delete media_source;
+            }
+        }
+    }
 #if !LL_LINUX
-	LL_WARNS_ONCE("Plugin") << "plugin initialization failed for mime type: " << media_type << LL_ENDL;
+    LL_WARNS_ONCE("Plugin") << "plugin initialization failed for mime type: " << media_type << LL_ENDL;
 #endif
 
-	if(gAgent.isInitialized())
-	{
-	    if (std::find(sMimeTypesFailed.begin(), sMimeTypesFailed.end(), media_type) == sMimeTypesFailed.end())
-	    {
-	        LLSD args;
-	        args["MIME_TYPE"] = media_type;
-	        LLNotificationsUtil::add("NoPlugin", args);
-	        sMimeTypesFailed.push_back(media_type);
-	    }
-	}
-	return NULL;
+    if(gAgent.isInitialized())
+    {
+        if (std::find(sMimeTypesFailed.begin(), sMimeTypesFailed.end(), media_type) == sMimeTypesFailed.end())
+        {
+            LLSD args;
+            args["MIME_TYPE"] = media_type;
+            LLNotificationsUtil::add("NoPlugin", args);
+            sMimeTypesFailed.push_back(media_type);
+        }
+    }
+    return NULL;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMediaImpl::initializePlugin(const std::string& media_type)
 {
-	if(mMediaSource)
-	{
-		// Save the previous media source's last set size before destroying it.
-		mMediaWidth = mMediaSource->getSetWidth();
-		mMediaHeight = mMediaSource->getSetHeight();
-		mZoomFactor = mMediaSource->getZoomFactor();
-	}
-
-	// Always delete the old media impl first.
-	destroyMediaSource();
+    if(mMediaSource)
+    {
+        // Save the previous media source's last set size before destroying it.
+        mMediaWidth = mMediaSource->getSetWidth();
+        mMediaHeight = mMediaSource->getSetHeight();
+        mZoomFactor = mMediaSource->getZoomFactor();
+    }
 
-	// and unconditionally set the mime type
-	mMimeType = media_type;
+    // Always delete the old media impl first.
+    destroyMediaSource();
 
-	if(mPriority == LLPluginClassMedia::PRIORITY_UNLOADED)
-	{
-		// This impl should not be loaded at this time.
-		LL_DEBUGS("PluginPriority") << this << "Not loading (PRIORITY_UNLOADED)" << LL_ENDL;
+    // and unconditionally set the mime type
+    mMimeType = media_type;
 
-		return false;
-	}
+    if(mPriority == LLPluginClassMedia::PRIORITY_UNLOADED)
+    {
+        // This impl should not be loaded at this time.
+        LL_DEBUGS("PluginPriority") << this << "Not loading (PRIORITY_UNLOADED)" << LL_ENDL;
 
-	// If we got here, we want to ignore previous init failures.
-	mMediaSourceFailed = false;
+        return false;
+    }
 
-	// Save the MIME type that really caused the plugin to load
-	mCurrentMimeType = mMimeType;
+    // If we got here, we want to ignore previous init failures.
+    mMediaSourceFailed = false;
 
-	LLPluginClassMedia* media_source = newSourceFromMediaType(mMimeType, this, mMediaWidth, mMediaHeight, mZoomFactor, mTarget, mCleanBrowser);
+    // Save the MIME type that really caused the plugin to load
+    mCurrentMimeType = mMimeType;
 
-	if (media_source)
-	{
-		media_source->injectOpenIDCookie();
-		media_source->setDisableTimeout(gSavedSettings.getBOOL("DebugPluginDisableTimeout"));
-		media_source->setLoop(mMediaLoop);
-		media_source->setAutoScale(mMediaAutoScale);
-		media_source->setBrowserUserAgent(LLViewerMedia::getInstance()->getCurrentUserAgent());
-		media_source->focus(mHasFocus);
-		media_source->setBackgroundColor(mBackgroundColor);
+    LLPluginClassMedia* media_source = newSourceFromMediaType(mMimeType, this, mMediaWidth, mMediaHeight, mZoomFactor, mTarget, mCleanBrowser);
 
-		if(gSavedSettings.getBOOL("BrowserIgnoreSSLCertErrors"))
-		{
-			media_source->ignore_ssl_cert_errors(true);
-		}
+    if (media_source)
+    {
+        media_source->injectOpenIDCookie();
+        media_source->setDisableTimeout(gSavedSettings.getBOOL("DebugPluginDisableTimeout"));
+        media_source->setLoop(mMediaLoop);
+        media_source->setAutoScale(mMediaAutoScale);
+        media_source->setBrowserUserAgent(LLViewerMedia::getInstance()->getCurrentUserAgent());
+        media_source->focus(mHasFocus);
+        media_source->setBackgroundColor(mBackgroundColor);
+
+        if(gSavedSettings.getBOOL("BrowserIgnoreSSLCertErrors"))
+        {
+            media_source->ignore_ssl_cert_errors(true);
+        }
 
-		// the correct way to deal with certs it to load ours from ca-bundle.crt and append them to the ones
-		// Qt/WebKit loads from your system location.
-		std::string ca_path = gDirUtilp->getCAFile();
-		media_source->addCertificateFilePath( ca_path );
+        // the correct way to deal with certs it to load ours from ca-bundle.crt and append them to the ones
+        // Qt/WebKit loads from your system location.
+        std::string ca_path = gDirUtilp->getCAFile();
+        media_source->addCertificateFilePath( ca_path );
 
-		if(mClearCache)
-		{
-			mClearCache = false;
-			media_source->clear_cache();
-		}
+        if(mClearCache)
+        {
+            mClearCache = false;
+            media_source->clear_cache();
+        }
 
-		mMediaSource.reset(media_source);
-		mMediaSource->setDeleteOK(false) ;
-		updateVolume();
+        mMediaSource.reset(media_source);
+        mMediaSource->setDeleteOK(false) ;
+        updateVolume();
 
-		return true;
-	}
+        return true;
+    }
 
-	// Make sure the timer doesn't try re-initing this plugin repeatedly until something else changes.
-	mMediaSourceFailed = true;
+    // Make sure the timer doesn't try re-initing this plugin repeatedly until something else changes.
+    mMediaSourceFailed = true;
 
-	return false;
+    return false;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::loadURI()
 {
-	if(mMediaSource)
-	{
-		// trim whitespace from front and back of URL - fixes EXT-5363
-		LLStringUtil::trim( mMediaURL );
+    if(mMediaSource)
+    {
+        // trim whitespace from front and back of URL - fixes EXT-5363
+        LLStringUtil::trim( mMediaURL );
 
-		// URI often comes unescaped
-		std::string uri = LLURI::escapePathAndData(mMediaURL);
+        // URI often comes unescaped
+        std::string uri = LLURI::escapePathAndData(mMediaURL);
         {
             // Do not log the query parts
             LLURI u(uri);
@@ -1895,389 +1895,389 @@ void LLViewerMediaImpl::loadURI()
             LL_INFOS() << "Asking media source to load URI: " << sanitized_uri << LL_ENDL;
         }
 
-		mMediaSource->loadURI( uri );
+        mMediaSource->loadURI( uri );
 
-		// A non-zero mPreviousMediaTime means that either this media was previously unloaded by the priority code while playing/paused,
-		// or a seek happened before the media loaded.  In either case, seek to the saved time.
-		if(mPreviousMediaTime != 0.0f)
-		{
-			seek(mPreviousMediaTime);
-		}
+        // A non-zero mPreviousMediaTime means that either this media was previously unloaded by the priority code while playing/paused,
+        // or a seek happened before the media loaded.  In either case, seek to the saved time.
+        if(mPreviousMediaTime != 0.0f)
+        {
+            seek(mPreviousMediaTime);
+        }
 
-		if(mPreviousMediaState == MEDIA_PLAYING)
-		{
-			// This media was playing before this instance was unloaded.
-			start();
-		}
-		else if(mPreviousMediaState == MEDIA_PAUSED)
-		{
-			// This media was paused before this instance was unloaded.
-			pause();
-		}
-		else
-		{
-			// No relevant previous media play state -- if we're loading the URL, we want to start playing.
-			start();
-		}
-	}
+        if(mPreviousMediaState == MEDIA_PLAYING)
+        {
+            // This media was playing before this instance was unloaded.
+            start();
+        }
+        else if(mPreviousMediaState == MEDIA_PAUSED)
+        {
+            // This media was paused before this instance was unloaded.
+            pause();
+        }
+        else
+        {
+            // No relevant previous media play state -- if we're loading the URL, we want to start playing.
+            start();
+        }
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::executeJavaScript(const std::string& code)
 {
-	if (mMediaSource)
-	{
-		mMediaSource->executeJavaScript(code);
-	}
+    if (mMediaSource)
+    {
+        mMediaSource->executeJavaScript(code);
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::setSize(int width, int height)
 {
-	mMediaWidth = width;
-	mMediaHeight = height;
-	if(mMediaSource)
-	{
-		mMediaSource->setSize(width, height);
-	}
+    mMediaWidth = width;
+    mMediaHeight = height;
+    if(mMediaSource)
+    {
+        mMediaSource->setSize(width, height);
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::showNotification(LLNotificationPtr notify)
 {
-	mNotification = notify;
+    mNotification = notify;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::hideNotification()
 {
-	mNotification.reset();
+    mNotification.reset();
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::play()
 {
-	// If the media source isn't there, try to initialize it and load an URL.
-	if(mMediaSource == NULL)
-	{
-	 	if(!initializeMedia(mMimeType))
-		{
-			// This may be the case where the plugin's priority is PRIORITY_UNLOADED
-			return;
-		}
+    // If the media source isn't there, try to initialize it and load an URL.
+    if(mMediaSource == NULL)
+    {
+        if(!initializeMedia(mMimeType))
+        {
+            // This may be the case where the plugin's priority is PRIORITY_UNLOADED
+            return;
+        }
 
-		// Only do this if the media source was just loaded.
-		loadURI();
-	}
+        // Only do this if the media source was just loaded.
+        loadURI();
+    }
 
-	// always start the media
-	start();
+    // always start the media
+    start();
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::stop()
 {
-	if(mMediaSource)
-	{
-		mMediaSource->stop();
-		// destroyMediaSource();
-	}
+    if(mMediaSource)
+    {
+        mMediaSource->stop();
+        // destroyMediaSource();
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::pause()
 {
-	if(mMediaSource)
-	{
-		mMediaSource->pause();
-	}
-	else
-	{
-		mPreviousMediaState = MEDIA_PAUSED;
-	}
+    if(mMediaSource)
+    {
+        mMediaSource->pause();
+    }
+    else
+    {
+        mPreviousMediaState = MEDIA_PAUSED;
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::start()
 {
-	if(mMediaSource)
-	{
-		mMediaSource->start();
-	}
-	else
-	{
-		mPreviousMediaState = MEDIA_PLAYING;
-	}
+    if(mMediaSource)
+    {
+        mMediaSource->start();
+    }
+    else
+    {
+        mPreviousMediaState = MEDIA_PLAYING;
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::seek(F32 time)
 {
-	if(mMediaSource)
-	{
-		mMediaSource->seek(time);
-	}
-	else
-	{
-		// Save the seek time to be set when the media is loaded.
-		mPreviousMediaTime = time;
-	}
+    if(mMediaSource)
+    {
+        mMediaSource->seek(time);
+    }
+    else
+    {
+        // Save the seek time to be set when the media is loaded.
+        mPreviousMediaTime = 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);
-		}
-	}
+    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);
-		}
-	}
+    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;
-	updateVolume();
+    mRequestedVolume = volume;
+    updateVolume();
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::setMute(bool mute)
 {
-	if (mute)
-	{
-		mPreviousVolume = mRequestedVolume;
-		setVolume(0.0);
-	}
-	else
-	{
-		setVolume(mPreviousVolume);
-	}
+    if (mute)
+    {
+        mPreviousVolume = mRequestedVolume;
+        setVolume(0.0);
+    }
+    else
+    {
+        setVolume(mPreviousVolume);
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::updateVolume()
 {
     LL_RECORD_BLOCK_TIME(FTM_MEDIA_UPDATE_VOLUME);
-	if(mMediaSource)
-	{
-		// always scale the volume by the global media volume
-		F32 volume = mRequestedVolume * LLViewerMedia::getInstance()->getVolume();
-
-		if (mProximityCamera > 0)
-		{
-			if (mProximityCamera > gSavedSettings.getF32("MediaRollOffMax"))
-			{
-				volume = 0;
-			}
-			else if (mProximityCamera > gSavedSettings.getF32("MediaRollOffMin"))
-			{
-				// attenuated_volume = 1 / (roll_off_rate * (d - min))^2
-				// the +1 is there so that for distance 0 the volume stays the same
-				F64 adjusted_distance = mProximityCamera - gSavedSettings.getF32("MediaRollOffMin");
-				F64 attenuation = 1.0 + (gSavedSettings.getF32("MediaRollOffRate") * adjusted_distance);
-				attenuation = 1.0 / (attenuation * attenuation);
-				// the attenuation multiplier should never be more than one since that would increase volume
-				volume = volume * llmin(1.0, attenuation);
-			}
-		}
-
-		if (sOnlyAudibleTextureID == LLUUID::null || sOnlyAudibleTextureID == mTextureId)
-		{
-			mMediaSource->setVolume(volume);
-		}
-		else
-		{
-			mMediaSource->setVolume(0.0f);
-		}
-	}
+    if(mMediaSource)
+    {
+        // always scale the volume by the global media volume
+        F32 volume = mRequestedVolume * LLViewerMedia::getInstance()->getVolume();
+
+        if (mProximityCamera > 0)
+        {
+            if (mProximityCamera > gSavedSettings.getF32("MediaRollOffMax"))
+            {
+                volume = 0;
+            }
+            else if (mProximityCamera > gSavedSettings.getF32("MediaRollOffMin"))
+            {
+                // attenuated_volume = 1 / (roll_off_rate * (d - min))^2
+                // the +1 is there so that for distance 0 the volume stays the same
+                F64 adjusted_distance = mProximityCamera - gSavedSettings.getF32("MediaRollOffMin");
+                F64 attenuation = 1.0 + (gSavedSettings.getF32("MediaRollOffRate") * adjusted_distance);
+                attenuation = 1.0 / (attenuation * attenuation);
+                // the attenuation multiplier should never be more than one since that would increase volume
+                volume = volume * llmin(1.0, attenuation);
+            }
+        }
+
+        if (sOnlyAudibleTextureID == LLUUID::null || sOnlyAudibleTextureID == mTextureId)
+        {
+            mMediaSource->setVolume(volume);
+        }
+        else
+        {
+            mMediaSource->setVolume(0.0f);
+        }
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 F32 LLViewerMediaImpl::getVolume()
 {
-	return mRequestedVolume;
+    return mRequestedVolume;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::focus(bool focus)
 {
-	mHasFocus = focus;
+    mHasFocus = focus;
 
-	if (mMediaSource)
-	{
-		// call focus just for the hell of it, even though this apopears to be a nop
-		mMediaSource->focus(focus);
-		if (focus)
-		{
-			// spoof a mouse click to *actually* pass focus
-			// Don't do this anymore -- it actually clicks through now.
-//			mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_DOWN, 1, 1, 0);
-//			mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_UP, 1, 1, 0);
-		}
-	}
+    if (mMediaSource)
+    {
+        // call focus just for the hell of it, even though this apopears to be a nop
+        mMediaSource->focus(focus);
+        if (focus)
+        {
+            // spoof a mouse click to *actually* pass focus
+            // Don't do this anymore -- it actually clicks through now.
+//          mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_DOWN, 1, 1, 0);
+//          mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_UP, 1, 1, 0);
+        }
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMediaImpl::hasFocus() const
 {
-	// FIXME: This might be able to be a bit smarter by hooking into LLViewerMediaFocus, etc.
-	return mHasFocus;
+    // FIXME: This might be able to be a bit smarter by hooking into LLViewerMediaFocus, etc.
+    return mHasFocus;
 }
 
 std::string LLViewerMediaImpl::getCurrentMediaURL()
 {
-	if(!mCurrentMediaURL.empty())
-	{
-		return mCurrentMediaURL;
-	}
+    if(!mCurrentMediaURL.empty())
+    {
+        return mCurrentMediaURL;
+    }
 
-	return mMediaURL;
+    return mMediaURL;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::clearCache()
 {
-	if(mMediaSource)
-	{
-		mMediaSource->clear_cache();
-	}
-	else
-	{
-		mClearCache = true;
-	}
+    if(mMediaSource)
+    {
+        mMediaSource->clear_cache();
+    }
+    else
+    {
+        mClearCache = true;
+    }
 }
 
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::setPageZoomFactor( double factor )
 {
-	if(mMediaSource && factor != mZoomFactor)
-	{
-		mZoomFactor = factor;
-		mMediaSource->set_page_zoom_factor( factor );
-	}
+    if(mMediaSource && factor != mZoomFactor)
+    {
+        mZoomFactor = factor;
+        mMediaSource->set_page_zoom_factor( factor );
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::mouseDown(S32 x, S32 y, MASK mask, S32 button)
 {
-	scaleMouse(&x, &y);
-	mLastMouseX = x;
-	mLastMouseY = y;
-//	LL_INFOS() << "mouse down (" << x << ", " << y << ")" << LL_ENDL;
-	if (mMediaSource)
-	{
-		mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_DOWN, button, x, y, mask);
-	}
+    scaleMouse(&x, &y);
+    mLastMouseX = x;
+    mLastMouseY = y;
+//  LL_INFOS() << "mouse down (" << x << ", " << y << ")" << LL_ENDL;
+    if (mMediaSource)
+    {
+        mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_DOWN, button, x, y, mask);
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::mouseUp(S32 x, S32 y, MASK mask, S32 button)
 {
-	scaleMouse(&x, &y);
-	mLastMouseX = x;
-	mLastMouseY = y;
-//	LL_INFOS() << "mouse up (" << x << ", " << y << ")" << LL_ENDL;
-	if (mMediaSource)
-	{
-		mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_UP, button, x, y, mask);
-	}
+    scaleMouse(&x, &y);
+    mLastMouseX = x;
+    mLastMouseY = y;
+//  LL_INFOS() << "mouse up (" << x << ", " << y << ")" << LL_ENDL;
+    if (mMediaSource)
+    {
+        mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_UP, button, x, y, mask);
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::mouseMove(S32 x, S32 y, MASK mask)
 {
     scaleMouse(&x, &y);
-	mLastMouseX = x;
-	mLastMouseY = y;
-//	LL_INFOS() << "mouse move (" << x << ", " << y << ")" << LL_ENDL;
-	if (mMediaSource)
-	{
-		mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_MOVE, 0, x, y, mask);
-	}
+    mLastMouseX = x;
+    mLastMouseY = y;
+//  LL_INFOS() << "mouse move (" << x << ", " << y << ")" << LL_ENDL;
+    if (mMediaSource)
+    {
+        mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_MOVE, 0, x, y, mask);
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 //static
 void LLViewerMediaImpl::scaleTextureCoords(const LLVector2& texture_coords, S32 *x, S32 *y)
 {
-	F32 texture_x = texture_coords.mV[VX];
-	F32 texture_y = texture_coords.mV[VY];
+    F32 texture_x = texture_coords.mV[VX];
+    F32 texture_y = texture_coords.mV[VY];
 
-	// Deal with repeating textures by wrapping the coordinates into the range [0, 1.0)
-	texture_x = fmodf(texture_x, 1.0f);
-	if(texture_x < 0.0f)
-		texture_x = 1.0 + texture_x;
+    // Deal with repeating textures by wrapping the coordinates into the range [0, 1.0)
+    texture_x = fmodf(texture_x, 1.0f);
+    if(texture_x < 0.0f)
+        texture_x = 1.0 + texture_x;
 
-	texture_y = fmodf(texture_y, 1.0f);
-	if(texture_y < 0.0f)
-		texture_y = 1.0 + texture_y;
+    texture_y = fmodf(texture_y, 1.0f);
+    if(texture_y < 0.0f)
+        texture_y = 1.0 + texture_y;
 
-	// scale x and y to texel units.
-	*x = ll_round(texture_x * mMediaSource->getTextureWidth());
-	*y = ll_round((1.0f - texture_y) * mMediaSource->getTextureHeight());
+    // scale x and y to texel units.
+    *x = ll_round(texture_x * mMediaSource->getTextureWidth());
+    *y = ll_round((1.0f - texture_y) * mMediaSource->getTextureHeight());
 
-	// Adjust for the difference between the actual texture height and the amount of the texture in use.
-	*y -= (mMediaSource->getTextureHeight() - mMediaSource->getHeight());
+    // Adjust for the difference between the actual texture height and the amount of the texture in use.
+    *y -= (mMediaSource->getTextureHeight() - mMediaSource->getHeight());
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::mouseDown(const LLVector2& texture_coords, MASK mask, S32 button)
 {
-	if(mMediaSource)
-	{
-		S32 x, y;
-		scaleTextureCoords(texture_coords, &x, &y);
+    if(mMediaSource)
+    {
+        S32 x, y;
+        scaleTextureCoords(texture_coords, &x, &y);
 
-		mouseDown(x, y, mask, button);
-	}
+        mouseDown(x, y, mask, button);
+    }
 }
 
 void LLViewerMediaImpl::mouseUp(const LLVector2& texture_coords, MASK mask, S32 button)
 {
-	if(mMediaSource)
-	{
-		S32 x, y;
-		scaleTextureCoords(texture_coords, &x, &y);
+    if(mMediaSource)
+    {
+        S32 x, y;
+        scaleTextureCoords(texture_coords, &x, &y);
 
-		mouseUp(x, y, mask, button);
-	}
+        mouseUp(x, y, mask, button);
+    }
 }
 
 void LLViewerMediaImpl::mouseMove(const LLVector2& texture_coords, MASK mask)
 {
-	if(mMediaSource)
-	{
-		S32 x, y;
-		scaleTextureCoords(texture_coords, &x, &y);
+    if(mMediaSource)
+    {
+        S32 x, y;
+        scaleTextureCoords(texture_coords, &x, &y);
 
-		mouseMove(x, y, mask);
-	}
+        mouseMove(x, y, mask);
+    }
 }
 
 void LLViewerMediaImpl::mouseDoubleClick(const LLVector2& texture_coords, MASK mask)
@@ -2294,13 +2294,13 @@ void LLViewerMediaImpl::mouseDoubleClick(const LLVector2& texture_coords, MASK m
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::mouseDoubleClick(S32 x, S32 y, MASK mask, S32 button)
 {
-	scaleMouse(&x, &y);
-	mLastMouseX = x;
-	mLastMouseY = y;
-	if (mMediaSource)
-	{
-		mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_DOUBLE_CLICK, button, x, y, mask);
-	}
+    scaleMouse(&x, &y);
+    mLastMouseX = x;
+    mLastMouseY = y;
+    if (mMediaSource)
+    {
+        mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_DOUBLE_CLICK, button, x, y, mask);
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -2318,196 +2318,196 @@ void LLViewerMediaImpl::scrollWheel(const LLVector2& texture_coords, S32 scroll_
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::scrollWheel(S32 x, S32 y, S32 scroll_x, S32 scroll_y, MASK mask)
 {
-	scaleMouse(&x, &y);
-	mLastMouseX = x;
-	mLastMouseY = y;
-	if (mMediaSource)
-	{
-		mMediaSource->scrollEvent(x, y, scroll_x, scroll_y, mask);
-	}
+    scaleMouse(&x, &y);
+    mLastMouseX = x;
+    mLastMouseY = y;
+    if (mMediaSource)
+    {
+        mMediaSource->scrollEvent(x, y, scroll_x, scroll_y, mask);
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::onMouseCaptureLost()
 {
-	if (mMediaSource)
-	{
-		mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_UP, 0, mLastMouseX, mLastMouseY, 0);
-	}
+    if (mMediaSource)
+    {
+        mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_UP, 0, mLastMouseX, mLastMouseY, 0);
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMediaImpl::handleMouseUp(S32 x, S32 y, MASK mask)
 {
-	// NOTE: this is called when the mouse is released when we have capture.
-	// Due to the way mouse coordinates are mapped to the object, we can't use the x and y coordinates that come in with the event.
+    // NOTE: this is called when the mouse is released when we have capture.
+    // Due to the way mouse coordinates are mapped to the object, we can't use the x and y coordinates that come in with the event.
 
-	if(hasMouseCapture())
-	{
-		// Release the mouse -- this will also send a mouseup to the media
-		gFocusMgr.setMouseCapture( nullptr );
-	}
+    if(hasMouseCapture())
+    {
+        // Release the mouse -- this will also send a mouseup to the media
+        gFocusMgr.setMouseCapture( nullptr );
+    }
 
-	return true;
+    return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::updateJavascriptObject()
 {
-	static LLFrameTimer timer ;
-
-	if ( mMediaSource )
-	{
-		// flag to expose this information to internal browser or not.
-		bool enable = gSavedSettings.getBOOL("BrowserEnableJSObject");
-
-		if(!enable)
-		{
-			return ; //no need to go further.
-		}
-
-		if(timer.getElapsedTimeF32() < 1.0f)
-		{
-			return ; //do not update more than once per second.
-		}
-		timer.reset() ;
-
-		mMediaSource->jsEnableObject( enable );
-
-		// these values are only menaingful after login so don't set them before
-		bool logged_in = LLLoginInstance::getInstance()->authSuccess();
-		if ( logged_in )
-		{
-			// current location within a region
-			LLVector3 agent_pos = gAgent.getPositionAgent();
-			double x = agent_pos.mV[ VX ];
-			double y = agent_pos.mV[ VY ];
-			double z = agent_pos.mV[ VZ ];
-			mMediaSource->jsAgentLocationEvent( x, y, z );
-
-			// current location within the grid
-			LLVector3d agent_pos_global = gAgent.getLastPositionGlobal();
-			double global_x = agent_pos_global.mdV[ VX ];
-			double global_y = agent_pos_global.mdV[ VY ];
-			double global_z = agent_pos_global.mdV[ VZ ];
-			mMediaSource->jsAgentGlobalLocationEvent( global_x, global_y, global_z );
-
-			// current agent orientation
-			double rotation = atan2( gAgent.getAtAxis().mV[VX], gAgent.getAtAxis().mV[VY] );
-			double angle = rotation * RAD_TO_DEG;
-			if ( angle < 0.0f ) angle = 360.0f + angle;	// TODO: has to be a better way to get orientation!
-			mMediaSource->jsAgentOrientationEvent( angle );
-
-			// current region agent is in
-			std::string region_name("");
-			LLViewerRegion* region = gAgent.getRegion();
-			if ( region )
-			{
-				region_name = region->getName();
-			};
-			mMediaSource->jsAgentRegionEvent( region_name );
-		}
-
-		// language code the viewer is set to
-		mMediaSource->jsAgentLanguageEvent( LLUI::getLanguage() );
-
-		// maturity setting the agent has selected
-		if ( gAgent.prefersAdult() )
-			mMediaSource->jsAgentMaturityEvent( "GMA" );	// Adult means see adult, mature and general content
-		else
-		if ( gAgent.prefersMature() )
-			mMediaSource->jsAgentMaturityEvent( "GM" );	// Mature means see mature and general content
-		else
-		if ( gAgent.prefersPG() )
-			mMediaSource->jsAgentMaturityEvent( "G" );	// PG means only see General content
-	}
+    static LLFrameTimer timer ;
+
+    if ( mMediaSource )
+    {
+        // flag to expose this information to internal browser or not.
+        bool enable = gSavedSettings.getBOOL("BrowserEnableJSObject");
+
+        if(!enable)
+        {
+            return ; //no need to go further.
+        }
+
+        if(timer.getElapsedTimeF32() < 1.0f)
+        {
+            return ; //do not update more than once per second.
+        }
+        timer.reset() ;
+
+        mMediaSource->jsEnableObject( enable );
+
+        // these values are only menaingful after login so don't set them before
+        bool logged_in = LLLoginInstance::getInstance()->authSuccess();
+        if ( logged_in )
+        {
+            // current location within a region
+            LLVector3 agent_pos = gAgent.getPositionAgent();
+            double x = agent_pos.mV[ VX ];
+            double y = agent_pos.mV[ VY ];
+            double z = agent_pos.mV[ VZ ];
+            mMediaSource->jsAgentLocationEvent( x, y, z );
+
+            // current location within the grid
+            LLVector3d agent_pos_global = gAgent.getLastPositionGlobal();
+            double global_x = agent_pos_global.mdV[ VX ];
+            double global_y = agent_pos_global.mdV[ VY ];
+            double global_z = agent_pos_global.mdV[ VZ ];
+            mMediaSource->jsAgentGlobalLocationEvent( global_x, global_y, global_z );
+
+            // current agent orientation
+            double rotation = atan2( gAgent.getAtAxis().mV[VX], gAgent.getAtAxis().mV[VY] );
+            double angle = rotation * RAD_TO_DEG;
+            if ( angle < 0.0f ) angle = 360.0f + angle; // TODO: has to be a better way to get orientation!
+            mMediaSource->jsAgentOrientationEvent( angle );
+
+            // current region agent is in
+            std::string region_name("");
+            LLViewerRegion* region = gAgent.getRegion();
+            if ( region )
+            {
+                region_name = region->getName();
+            };
+            mMediaSource->jsAgentRegionEvent( region_name );
+        }
+
+        // language code the viewer is set to
+        mMediaSource->jsAgentLanguageEvent( LLUI::getLanguage() );
+
+        // maturity setting the agent has selected
+        if ( gAgent.prefersAdult() )
+            mMediaSource->jsAgentMaturityEvent( "GMA" );    // Adult means see adult, mature and general content
+        else
+        if ( gAgent.prefersMature() )
+            mMediaSource->jsAgentMaturityEvent( "GM" ); // Mature means see mature and general content
+        else
+        if ( gAgent.prefersPG() )
+            mMediaSource->jsAgentMaturityEvent( "G" );  // PG means only see General content
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 const std::string& LLViewerMediaImpl::getName() const
 {
-	if (mMediaSource)
-	{
-		return mMediaSource->getMediaName();
-	}
+    if (mMediaSource)
+    {
+        return mMediaSource->getMediaName();
+    }
 
-	return LLStringUtil::null;
+    return LLStringUtil::null;
 };
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::navigateBack()
 {
-	if (mMediaSource)
-	{
-		mMediaSource->browse_back();
-	}
+    if (mMediaSource)
+    {
+        mMediaSource->browse_back();
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::navigateForward()
 {
-	if (mMediaSource)
-	{
-		mMediaSource->browse_forward();
-	}
+    if (mMediaSource)
+    {
+        mMediaSource->browse_forward();
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::navigateReload()
 {
-	navigateTo(getCurrentMediaURL(), "", true, false);
+    navigateTo(getCurrentMediaURL(), "", true, false);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::navigateHome()
 {
-	bool rediscover_mimetype = mHomeMimeType.empty();
-	navigateTo(mHomeURL, mHomeMimeType, rediscover_mimetype, false);
+    bool rediscover_mimetype = mHomeMimeType.empty();
+    navigateTo(mHomeURL, mHomeMimeType, rediscover_mimetype, false);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::unload()
 {
-	// Unload the media impl and clear its state.
-	destroyMediaSource();
-	resetPreviousMediaState();
-	mMediaURL.clear();
-	mMimeType.clear();
-	mCurrentMediaURL.clear();
-	mCurrentMimeType.clear();
+    // Unload the media impl and clear its state.
+    destroyMediaSource();
+    resetPreviousMediaState();
+    mMediaURL.clear();
+    mMimeType.clear();
+    mCurrentMediaURL.clear();
+    mCurrentMimeType.clear();
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::navigateTo(const std::string& url, const std::string& mime_type,  bool rediscover_type, bool server_request, bool clean_browser)
 {
-	cancelMimeTypeProbe();
+    cancelMimeTypeProbe();
 
-	if(mMediaURL != url)
-	{
-		// Don't carry media play state across distinct URLs.
-		resetPreviousMediaState();
-	}
+    if(mMediaURL != url)
+    {
+        // Don't carry media play state across distinct URLs.
+        resetPreviousMediaState();
+    }
 
-	// Always set the current URL and MIME type.
-	mMediaURL = url;
-	mMimeType = mime_type;
+    // Always set the current URL and MIME type.
+    mMediaURL = url;
+    mMimeType = mime_type;
     mCleanBrowser = clean_browser;
 
-	// Clear the current media URL, since it will no longer be correct.
-	mCurrentMediaURL.clear();
+    // Clear the current media URL, since it will no longer be correct.
+    mCurrentMediaURL.clear();
 
-	// if mime type discovery was requested, we'll need to do it when the media loads
-	mNavigateRediscoverType = rediscover_type;
+    // if mime type discovery was requested, we'll need to do it when the media loads
+    mNavigateRediscoverType = rediscover_type;
 
-	// and if this was a server request, the navigate on load will also need to be one.
-	mNavigateServerRequest = server_request;
+    // and if this was a server request, the navigate on load will also need to be one.
+    mNavigateServerRequest = server_request;
 
-	// An explicit navigate resets the "failed" flag.
-	mMediaSourceFailed = false;
+    // An explicit navigate resets the "failed" flag.
+    mMediaSourceFailed = false;
 
-	if(mPriority == LLPluginClassMedia::PRIORITY_UNLOADED)
-	{
-		// Helpful to have media urls in log file. Shouldn't be spammy.
+    if(mPriority == LLPluginClassMedia::PRIORITY_UNLOADED)
+    {
+        // Helpful to have media urls in log file. Shouldn't be spammy.
         {
             // Do not log the query parts
             LLURI u(url);
@@ -2515,19 +2515,19 @@ void LLViewerMediaImpl::navigateTo(const std::string& url, const std::string& mi
             LL_INFOS() << "NOT LOADING media id= " << mTextureId << " url=" << sanitized_url << ", mime_type=" << mime_type << LL_ENDL;
         }
 
-		// This impl should not be loaded at this time.
-		LL_DEBUGS("PluginPriority") << this << "Not loading (PRIORITY_UNLOADED)" << LL_ENDL;
+        // This impl should not be loaded at this time.
+        LL_DEBUGS("PluginPriority") << this << "Not loading (PRIORITY_UNLOADED)" << LL_ENDL;
 
-		return;
-	}
+        return;
+    }
 
-	navigateInternal();
+    navigateInternal();
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::navigateInternal()
 {
-	// Helpful to have media urls in log file. Shouldn't be spammy.
+    // Helpful to have media urls in log file. Shouldn't be spammy.
     {
         // Do not log the query parts
         LLURI u(mMediaURL);
@@ -2535,81 +2535,81 @@ void LLViewerMediaImpl::navigateInternal()
         LL_INFOS() << "media id= " << mTextureId << " url=" << sanitized_url << ", mime_type=" << mMimeType << LL_ENDL;
     }
 
-	if(mNavigateSuspended)
-	{
-		LL_WARNS() << "Deferring navigate." << LL_ENDL;
-		mNavigateSuspendedDeferred = true;
-		return;
-	}
-	
-    
+    if(mNavigateSuspended)
+    {
+        LL_WARNS() << "Deferring navigate." << LL_ENDL;
+        mNavigateSuspendedDeferred = true;
+        return;
+    }
+
+
     if (!mMimeProbe.expired())
-	{
-		LL_WARNS() << "MIME type probe already in progress -- bailing out." << LL_ENDL;
-		return;
-	}
-
-	if(mNavigateServerRequest)
-	{
-		setNavState(MEDIANAVSTATE_SERVER_SENT);
-	}
-	else
-	{
-		setNavState(MEDIANAVSTATE_NONE);
-	}
-
-	// If the caller has specified a non-empty MIME type, look that up in our MIME types list.
-	// If we have a plugin for that MIME type, use that instead of attempting auto-discovery.
-	// This helps in supporting legacy media content where the server the media resides on returns a bogus MIME type
-	// but the parcel owner has correctly set the MIME type in the parcel media settings.
-
-	if(!mMimeType.empty() && (mMimeType != LLMIMETypes::getDefaultMimeType()))
-	{
-		std::string plugin_basename = LLMIMETypes::implType(mMimeType);
-		if(!plugin_basename.empty())
-		{
-			// We have a plugin for this mime type
-			mNavigateRediscoverType = false;
-		}
-	}
-
-	if(mNavigateRediscoverType)
-	{
-
-		LLURI uri(mMediaURL);
-		std::string scheme = uri.scheme();
-
-		if(scheme.empty() || "http" == scheme || "https" == scheme)
-		{
+    {
+        LL_WARNS() << "MIME type probe already in progress -- bailing out." << LL_ENDL;
+        return;
+    }
+
+    if(mNavigateServerRequest)
+    {
+        setNavState(MEDIANAVSTATE_SERVER_SENT);
+    }
+    else
+    {
+        setNavState(MEDIANAVSTATE_NONE);
+    }
+
+    // If the caller has specified a non-empty MIME type, look that up in our MIME types list.
+    // If we have a plugin for that MIME type, use that instead of attempting auto-discovery.
+    // This helps in supporting legacy media content where the server the media resides on returns a bogus MIME type
+    // but the parcel owner has correctly set the MIME type in the parcel media settings.
+
+    if(!mMimeType.empty() && (mMimeType != LLMIMETypes::getDefaultMimeType()))
+    {
+        std::string plugin_basename = LLMIMETypes::implType(mMimeType);
+        if(!plugin_basename.empty())
+        {
+            // We have a plugin for this mime type
+            mNavigateRediscoverType = false;
+        }
+    }
+
+    if(mNavigateRediscoverType)
+    {
+
+        LLURI uri(mMediaURL);
+        std::string scheme = uri.scheme();
+
+        if(scheme.empty() || "http" == scheme || "https" == scheme)
+        {
             LLCoros::instance().launch("LLViewerMediaImpl::mimeDiscoveryCoro",
                 boost::bind(&LLViewerMediaImpl::mimeDiscoveryCoro, this, mMediaURL));
-		}
-		else if("data" == scheme || "file" == scheme || "about" == scheme)
-		{
-			// FIXME: figure out how to really discover the type for these schemes
-			// We use "data" internally for a text/html url for loading the login screen
-			if(initializeMedia(HTTP_CONTENT_TEXT_HTML))
-			{
-				loadURI();
-			}
-		}
-		else
-		{
-			// This catches 'rtsp://' urls
-			if(initializeMedia(scheme))
-			{
-				loadURI();
-			}
-		}
-	}
-	else if(initializeMedia(mMimeType))
-	{
-		loadURI();
-	}
-	else
-	{
-		LL_WARNS("Media") << "Couldn't navigate to: " << mMediaURL << " as there is no media type for: " << mMimeType << LL_ENDL;
-	}
+        }
+        else if("data" == scheme || "file" == scheme || "about" == scheme)
+        {
+            // FIXME: figure out how to really discover the type for these schemes
+            // We use "data" internally for a text/html url for loading the login screen
+            if(initializeMedia(HTTP_CONTENT_TEXT_HTML))
+            {
+                loadURI();
+            }
+        }
+        else
+        {
+            // This catches 'rtsp://' urls
+            if(initializeMedia(scheme))
+            {
+                loadURI();
+            }
+        }
+    }
+    else if(initializeMedia(mMimeType))
+    {
+        loadURI();
+    }
+    else
+    {
+        LL_WARNS("Media") << "Couldn't navigate to: " << mMediaURL << " as there is no media type for: " << mMimeType << LL_ENDL;
+    }
 }
 
 void LLViewerMediaImpl::mimeDiscoveryCoro(std::string url)
@@ -2690,100 +2690,100 @@ void LLViewerMediaImpl::mimeDiscoveryCoro(std::string url)
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::navigateStop()
 {
-	if(mMediaSource)
-	{
-		mMediaSource->browse_stop();
-	}
+    if(mMediaSource)
+    {
+        mMediaSource->browse_stop();
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMediaImpl::handleKeyHere(KEY key, MASK mask)
 {
-	bool result = false;
+    bool result = false;
 
-	if (mMediaSource)
-	{
-		// FIXME: THIS IS SO WRONG.
-		// Menu keys should be handled by the menu system and not passed to UI elements, but this is how LLTextEditor and LLLineEditor do it...
-		if (MASK_CONTROL & mask && key != KEY_LEFT && key != KEY_RIGHT && key != KEY_HOME && key != KEY_END)
-		{
-			result = true;
-		}
+    if (mMediaSource)
+    {
+        // FIXME: THIS IS SO WRONG.
+        // Menu keys should be handled by the menu system and not passed to UI elements, but this is how LLTextEditor and LLLineEditor do it...
+        if (MASK_CONTROL & mask && key != KEY_LEFT && key != KEY_RIGHT && key != KEY_HOME && key != KEY_END)
+        {
+            result = true;
+        }
 
-		if (!result)
-		{
+        if (!result)
+        {
             LLSD native_key_data = gViewerWindow->getWindow()->getNativeKeyData();
-			result = mMediaSource->keyEvent(LLPluginClassMedia::KEY_EVENT_DOWN, key, mask, native_key_data);
-		}
-	}
+            result = mMediaSource->keyEvent(LLPluginClassMedia::KEY_EVENT_DOWN, key, mask, native_key_data);
+        }
+    }
 
-	return result;
+    return result;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMediaImpl::handleKeyUpHere(KEY key, MASK mask)
 {
-	bool result = false;
+    bool result = false;
 
-	if (mMediaSource)
-	{
-		// FIXME: THIS IS SO WRONG.
-		// Menu keys should be handled by the menu system and not passed to UI elements, but this is how LLTextEditor and LLLineEditor do it...
-		if (MASK_CONTROL & mask && key != KEY_LEFT && key != KEY_RIGHT && key != KEY_HOME && key != KEY_END)
-		{
-			result = true;
-		}
+    if (mMediaSource)
+    {
+        // FIXME: THIS IS SO WRONG.
+        // Menu keys should be handled by the menu system and not passed to UI elements, but this is how LLTextEditor and LLLineEditor do it...
+        if (MASK_CONTROL & mask && key != KEY_LEFT && key != KEY_RIGHT && key != KEY_HOME && key != KEY_END)
+        {
+            result = true;
+        }
 
-		if (!result)
-		{
-			LLSD native_key_data = gViewerWindow->getWindow()->getNativeKeyData();
-			result = mMediaSource->keyEvent(LLPluginClassMedia::KEY_EVENT_UP, key, mask, native_key_data);
-		}
-	}
+        if (!result)
+        {
+            LLSD native_key_data = gViewerWindow->getWindow()->getNativeKeyData();
+            result = mMediaSource->keyEvent(LLPluginClassMedia::KEY_EVENT_UP, key, mask, native_key_data);
+        }
+    }
 
-	return result;
+    return result;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMediaImpl::handleUnicodeCharHere(llwchar uni_char)
 {
-	bool result = false;
+    bool result = false;
 
-	if (mMediaSource)
-	{
-		// only accept 'printable' characters, sigh...
-		if (uni_char >= 32 // discard 'control' characters
-			&& uni_char != 127) // SDL thinks this is 'delete' - yuck.
-		{
-			LLSD native_key_data = gViewerWindow->getWindow()->getNativeKeyData();
+    if (mMediaSource)
+    {
+        // only accept 'printable' characters, sigh...
+        if (uni_char >= 32 // discard 'control' characters
+            && uni_char != 127) // SDL thinks this is 'delete' - yuck.
+        {
+            LLSD native_key_data = gViewerWindow->getWindow()->getNativeKeyData();
 
-			mMediaSource->textInput(wstring_to_utf8str(LLWString(1, uni_char)), gKeyboard->currentMask(false), native_key_data);
-		}
-	}
+            mMediaSource->textInput(wstring_to_utf8str(LLWString(1, uni_char)), gKeyboard->currentMask(false), native_key_data);
+        }
+    }
 
-	return result;
+    return result;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMediaImpl::canNavigateForward()
 {
-	bool result = false;
-	if (mMediaSource)
-	{
-		result = mMediaSource->getHistoryForwardAvailable();
-	}
-	return result;
+    bool result = false;
+    if (mMediaSource)
+    {
+        result = mMediaSource->getHistoryForwardAvailable();
+    }
+    return result;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMediaImpl::canNavigateBack()
 {
-	bool result = false;
-	if (mMediaSource)
-	{
-		result = mMediaSource->getHistoryBackAvailable();
-	}
-	return result;
+    bool result = false;
+    if (mMediaSource)
+    {
+        result = mMediaSource->getHistoryBackAvailable();
+    }
+    return result;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -2870,7 +2870,7 @@ void LLViewerMediaImpl::update()
         return;
     }
 
-    
+
     LLViewerMediaTexture* media_tex;
     U8* data;
     S32 data_width;
@@ -2984,7 +2984,7 @@ void LLViewerMediaImpl::doMediaTexUpdate(LLViewerMediaTexture* media_tex, U8* da
 
     // copy just the subimage covered by the image raw to GL
     media_tex->setSubImage(data, data_width, data_height, x_pos, y_pos, width, height, tex_name);
-    
+
     if (sync)
     {
         media_tex->getGLTexture()->syncToMainThread(tex_name);
@@ -2993,7 +2993,7 @@ void LLViewerMediaImpl::doMediaTexUpdate(LLViewerMediaTexture* media_tex, U8* da
     {
         media_tex->getGLTexture()->syncTexName(tex_name);
     }
-    
+
     // release the data pointer before freeing raw so LLImageRaw destructor doesn't
     // free memory at data pointer
     raw->releaseData();
@@ -3017,7 +3017,7 @@ LLViewerMediaTexture* LLViewerMediaImpl::updateMediaImage()
     //llassert(!mTextureId.isNull());
     // *TODO: Consider enabling mipmaps (they have been disabled for a long time). Likely has a significant performance impact for tiled/high texture repeat media. Mip generation in a shader may also be an option if necessary.
     LLViewerMediaTexture* media_tex = LLViewerTextureManager::getMediaTexture( mTextureId, USE_MIPMAPS );
- 
+
     if ( mNeedsNewTexture
         || (media_tex->getWidth() != mMediaSource->getTextureWidth())
         || (media_tex->getHeight() != mMediaSource->getTextureHeight())
@@ -3053,7 +3053,7 @@ LLViewerMediaTexture* LLViewerMediaImpl::updateMediaImage()
 
         // MEDIAOPT: set this dynamically on play/stop
         // FIXME
-//		media_tex->mIsMediaTexture = true;
+//      media_tex->mIsMediaTexture = true;
         mNeedsNewTexture = false;
 
         // If the amount of the texture being drawn by the media goes down in either width or height,
@@ -3068,45 +3068,45 @@ LLViewerMediaTexture* LLViewerMediaImpl::updateMediaImage()
 //////////////////////////////////////////////////////////////////////////////////////////
 LLUUID LLViewerMediaImpl::getMediaTextureID() const
 {
-	return mTextureId;
+    return mTextureId;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::setVisible(bool visible)
 {
-	mVisible = visible;
+    mVisible = visible;
 
-	if(mVisible)
-	{
-		if(mMediaSource && mMediaSource->isPluginExited())
-		{
-			destroyMediaSource();
-		}
+    if(mVisible)
+    {
+        if(mMediaSource && mMediaSource->isPluginExited())
+        {
+            destroyMediaSource();
+        }
 
-		if(!mMediaSource)
-		{
-			createMediaSource();
-		}
-	}
+        if(!mMediaSource)
+        {
+            createMediaSource();
+        }
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::mouseCapture()
 {
-	gFocusMgr.setMouseCapture(this);
+    gFocusMgr.setMouseCapture(this);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::scaleMouse(S32 *mouse_x, S32 *mouse_y)
 {
 #if 0
-	S32 media_width, media_height;
-	S32 texture_width, texture_height;
-	getMediaSize( &media_width, &media_height );
-	getTextureSize( &texture_width, &texture_height );
-	S32 y_delta = texture_height - media_height;
+    S32 media_width, media_height;
+    S32 texture_width, texture_height;
+    getMediaSize( &media_width, &media_height );
+    getTextureSize( &texture_width, &texture_height );
+    S32 y_delta = texture_height - media_height;
 
-	*mouse_y -= y_delta;
+    *mouse_y -= y_delta;
 #endif
 }
 
@@ -3115,57 +3115,57 @@ void LLViewerMediaImpl::scaleMouse(S32 *mouse_x, S32 *mouse_y)
 //////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMediaImpl::isMediaTimeBased()
 {
-	bool result = false;
+    bool result = false;
 
-	if(mMediaSource)
-	{
-		result = mMediaSource->pluginSupportsMediaTime();
-	}
+    if(mMediaSource)
+    {
+        result = mMediaSource->pluginSupportsMediaTime();
+    }
 
-	return result;
+    return result;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMediaImpl::isMediaPlaying()
 {
-	bool result = false;
+    bool result = false;
 
-	if(mMediaSource)
-	{
-		EMediaStatus status = mMediaSource->getStatus();
-		if(status == MEDIA_PLAYING || status == MEDIA_LOADING)
-			result = true;
-	}
+    if(mMediaSource)
+    {
+        EMediaStatus status = mMediaSource->getStatus();
+        if(status == MEDIA_PLAYING || status == MEDIA_LOADING)
+            result = true;
+    }
 
-	return result;
+    return result;
 }
 //////////////////////////////////////////////////////////////////////////////////////////
 bool LLViewerMediaImpl::isMediaPaused()
 {
-	bool result = false;
+    bool result = false;
 
-	if(mMediaSource)
-	{
-		if(mMediaSource->getStatus() == MEDIA_PAUSED)
-			result = true;
-	}
+    if(mMediaSource)
+    {
+        if(mMediaSource->getStatus() == MEDIA_PAUSED)
+            result = true;
+    }
 
-	return result;
+    return result;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 //
 bool LLViewerMediaImpl::hasMedia() const
 {
-	return mMediaSource != NULL;
+    return mMediaSource != NULL;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 //
 void LLViewerMediaImpl::resetPreviousMediaState()
 {
-	mPreviousMediaState = MEDIA_NONE;
-	mPreviousMediaTime = 0.0f;
+    mPreviousMediaState = MEDIA_NONE;
+    mPreviousMediaTime = 0.0f;
 }
 
 
@@ -3173,318 +3173,318 @@ void LLViewerMediaImpl::resetPreviousMediaState()
 //
 void LLViewerMediaImpl::setDisabled(bool disabled, bool forcePlayOnEnable)
 {
-	if(mIsDisabled != disabled)
-	{
-		// Only do this on actual state transitions.
-		mIsDisabled = disabled;
-
-		if(mIsDisabled)
-		{
-			// We just disabled this media.  Clear all state.
-			unload();
-		}
-		else
-		{
-			// We just (re)enabled this media.  Do a navigate if auto-play is in order.
-			if(isAutoPlayable() || forcePlayOnEnable)
-			{
-				navigateTo(mMediaEntryURL, "", true, true);
-			}
-		}
-
-	}
+    if(mIsDisabled != disabled)
+    {
+        // Only do this on actual state transitions.
+        mIsDisabled = disabled;
+
+        if(mIsDisabled)
+        {
+            // We just disabled this media.  Clear all state.
+            unload();
+        }
+        else
+        {
+            // We just (re)enabled this media.  Do a navigate if auto-play is in order.
+            if(isAutoPlayable() || forcePlayOnEnable)
+            {
+                navigateTo(mMediaEntryURL, "", true, true);
+            }
+        }
+
+    }
 };
 
 //////////////////////////////////////////////////////////////////////////////////////////
 //
 bool LLViewerMediaImpl::isForcedUnloaded() const
 {
-	if(mIsMuted || mMediaSourceFailed || mIsDisabled)
-	{
-		return true;
-	}
+    if(mIsMuted || mMediaSourceFailed || mIsDisabled)
+    {
+        return true;
+    }
 
-	// If this media's class is not supposed to be shown, unload
-	if (!shouldShowBasedOnClass() || isObscured())
-	{
-		return true;
-	}
+    // If this media's class is not supposed to be shown, unload
+    if (!shouldShowBasedOnClass() || isObscured())
+    {
+        return true;
+    }
 
-	return false;
+    return false;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 //
 bool LLViewerMediaImpl::isPlayable() const
 {
-	if(isForcedUnloaded())
-	{
-		// All of the forced-unloaded criteria also imply not playable.
-		return false;
-	}
+    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(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;
-	}
+    if(!mMediaURL.empty())
+    {
+        // If something has navigated the instance, it's ready to be played.
+        return true;
+    }
 
-	return false;
+    return false;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::handleMediaEvent(LLPluginClassMedia* plugin, LLPluginClassMediaOwner::EMediaEvent event)
 {
-	bool pass_through = true;
-	switch(event)
-	{
-		case MEDIA_EVENT_CLICK_LINK_NOFOLLOW:
-		{
-			LL_DEBUGS("Media") << "MEDIA_EVENT_CLICK_LINK_NOFOLLOW, uri is: " << plugin->getClickURL() << LL_ENDL;
-			std::string url = plugin->getClickURL();
-			std::string nav_type = plugin->getClickNavType();
-			LLURLDispatcher::dispatch(url, nav_type, NULL, mTrustedBrowser);
-		}
-		break;
-		case MEDIA_EVENT_CLICK_LINK_HREF:
-		{
-			LL_DEBUGS("Media") <<  "Media event:  MEDIA_EVENT_CLICK_LINK_HREF, target is \"" << plugin->getClickTarget() << "\", uri is " << plugin->getClickURL() << LL_ENDL;
-		};
-		break;
-		case MEDIA_EVENT_PLUGIN_FAILED_LAUNCH:
-		{
-			// The plugin failed to load properly.  Make sure the timer doesn't retry.
-			// TODO: maybe mark this plugin as not loadable somehow?
-			mMediaSourceFailed = true;
-
-			// Reset the last known state of the media to defaults.
-			resetPreviousMediaState();
-
-			// TODO: may want a different message for this case?
-			LLSD args;
-			args["PLUGIN"] = LLMIMETypes::implType(mCurrentMimeType);
-			LLNotificationsUtil::add("MediaPluginFailed", args);
-		}
-		break;
-
-		case MEDIA_EVENT_PLUGIN_FAILED:
-		{
-			// The plugin crashed.
-			mMediaSourceFailed = true;
-
-			// Reset the last known state of the media to defaults.
-			resetPreviousMediaState();
-
-			LLSD args;
-			args["PLUGIN"] = LLMIMETypes::implType(mCurrentMimeType);
-			// SJB: This is getting called every frame if the plugin fails to load, continuously respawining the alert!
-			//LLNotificationsUtil::add("MediaPluginFailed", args);
-		}
-		break;
-
-		case MEDIA_EVENT_CURSOR_CHANGED:
-		{
-			LL_DEBUGS("Media") <<  "Media event:  MEDIA_EVENT_CURSOR_CHANGED, new cursor is " << plugin->getCursorName() << LL_ENDL;
-
-			std::string cursor = plugin->getCursorName();
-			mLastSetCursor = getCursorFromString(cursor);
-		}
-		break;
-
-		case LLViewerMediaObserver::MEDIA_EVENT_FILE_DOWNLOAD:
-		{
-			LL_DEBUGS("Media") << "Media event - file download requested - filename is " << plugin->getFileDownloadFilename() << LL_ENDL;
-		}
-		break;
-
-		case LLViewerMediaObserver::MEDIA_EVENT_NAVIGATE_BEGIN:
-		{
-			LL_DEBUGS("Media") << "MEDIA_EVENT_NAVIGATE_BEGIN, uri is: " << plugin->getNavigateURI() << LL_ENDL;
-			hideNotification();
-
-			if(getNavState() == MEDIANAVSTATE_SERVER_SENT)
-			{
-				setNavState(MEDIANAVSTATE_SERVER_BEGUN);
-			}
-			else
-			{
-				setNavState(MEDIANAVSTATE_BEGUN);
-			}
-		}
-		break;
-
-		case LLViewerMediaObserver::MEDIA_EVENT_NAVIGATE_COMPLETE:
-		{
-			LL_DEBUGS("Media") << "MEDIA_EVENT_NAVIGATE_COMPLETE, uri is: " << plugin->getNavigateURI() << LL_ENDL;
-
-			std::string url = plugin->getNavigateURI();
-			if(getNavState() == MEDIANAVSTATE_BEGUN)
-			{
-				if(mCurrentMediaURL == url)
-				{
-					// This is a navigate that takes us to the same url as the previous navigate.
-					setNavState(MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED_SPURIOUS);
-				}
-				else
-				{
-					mCurrentMediaURL = url;
-					setNavState(MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED);
-				}
-			}
-			else if(getNavState() == MEDIANAVSTATE_SERVER_BEGUN)
-			{
-				mCurrentMediaURL = url;
-				setNavState(MEDIANAVSTATE_SERVER_COMPLETE_BEFORE_LOCATION_CHANGED);
-			}
-			else
-			{
-				// all other cases need to leave the state alone.
-			}
-		}
-		break;
-
-		case LLViewerMediaObserver::MEDIA_EVENT_LOCATION_CHANGED:
-		{
-			LL_DEBUGS("Media") << "MEDIA_EVENT_LOCATION_CHANGED, uri is: " << plugin->getLocation() << LL_ENDL;
-
-			std::string url = plugin->getLocation();
-
-			if(getNavState() == MEDIANAVSTATE_BEGUN)
-			{
-				if(mCurrentMediaURL == url)
-				{
-					// This is a navigate that takes us to the same url as the previous navigate.
-					setNavState(MEDIANAVSTATE_FIRST_LOCATION_CHANGED_SPURIOUS);
-				}
-				else
-				{
-					mCurrentMediaURL = url;
-					setNavState(MEDIANAVSTATE_FIRST_LOCATION_CHANGED);
-				}
-			}
-			else if(getNavState() == MEDIANAVSTATE_SERVER_BEGUN)
-			{
-				mCurrentMediaURL = url;
-				setNavState(MEDIANAVSTATE_SERVER_FIRST_LOCATION_CHANGED);
-			}
-			else
-			{
-				bool internal_nav = false;
-				if (url != mCurrentMediaURL)
-				{
-					// Check if it is internal navigation
-					// Note: Not sure if we should detect internal navigations as 'address change',
-					// but they are not redirects and do not cause NAVIGATE_BEGIN (also see SL-1005)
-					size_t pos = url.find("#");
-					if (pos != std::string::npos)
-					{
-						// assume that new link always have '#', so this is either
-						// transfer from 'link#1' to 'link#2' or from link to 'link#2'
-						// filter out cases like 'redirect?link'
-						std::string base_url = url.substr(0, pos);
-						pos = mCurrentMediaURL.find(base_url);
-						if (pos == 0)
-						{
-							// base link hasn't changed
-							internal_nav = true;
-						}
-					}
-				}
-
-				if (internal_nav)
-				{
-					// Internal navigation by '#'
-					mCurrentMediaURL = url;
-					setNavState(MEDIANAVSTATE_FIRST_LOCATION_CHANGED);
-				}
-				else
-				{
-					// Don't track redirects.
-					setNavState(MEDIANAVSTATE_NONE);
-				}
-			}
-		}
-		break;
-
-		case LLViewerMediaObserver::MEDIA_EVENT_PICK_FILE_REQUEST:
-		{
-			LL_DEBUGS("Media") << "Media event - file pick requested." <<  LL_ENDL;
-
-			init_threaded_picker_load_dialog(plugin, LLFilePicker::FFLOAD_ALL, plugin->getIsMultipleFilePick());
-		}
-		break;
-
-		case LLViewerMediaObserver::MEDIA_EVENT_AUTH_REQUEST:
-		{
-			LLNotification::Params auth_request_params;
-			auth_request_params.name = "AuthRequest";
-
-			// pass in host name and realm for site (may be zero length but will always exist)
-			LLSD args;
-			LLURL raw_url( plugin->getAuthURL().c_str() );
-			args["HOST_NAME"] = raw_url.getAuthority();
-			args["REALM"] = plugin->getAuthRealm();
-			auth_request_params.substitutions = args;
-
-			auth_request_params.payload = LLSD().with("media_id", mTextureId);
-			auth_request_params.functor.function = boost::bind(&LLViewerMedia::authSubmitCallback, _1, _2);
-			LLNotifications::instance().add(auth_request_params);
-		};
-		break;
-
-		case LLViewerMediaObserver::MEDIA_EVENT_CLOSE_REQUEST:
-		{
-			std::string uuid = plugin->getClickUUID();
-
-			LL_INFOS() << "MEDIA_EVENT_CLOSE_REQUEST for uuid " << uuid << LL_ENDL;
-
-			if(uuid.empty())
-			{
-				// This close request is directed at this instance, let it fall through.
-			}
-			else
-			{
-				// This close request is directed at another instance
-				pass_through = false;
-				LLFloaterWebContent::closeRequest(uuid);
-			}
-		}
-		break;
-
-		case LLViewerMediaObserver::MEDIA_EVENT_GEOMETRY_CHANGE:
-		{
-			std::string uuid = plugin->getClickUUID();
-
-			LL_INFOS() << "MEDIA_EVENT_GEOMETRY_CHANGE for uuid " << uuid << LL_ENDL;
-
-			if(uuid.empty())
-			{
-				// This geometry change request is directed at this instance, let it fall through.
-			}
-			else
-			{
-				// This request is directed at another instance
-				pass_through = false;
-				LLFloaterWebContent::geometryChanged(uuid, plugin->getGeometryX(), plugin->getGeometryY(), plugin->getGeometryWidth(), plugin->getGeometryHeight());
-			}
-		}
-		break;
-
-		default:
-		break;
-	}
-
-	if(pass_through)
-	{
-		// Just chain the event to observers.
-		emitEvent(plugin, event);
-	}
+    bool pass_through = true;
+    switch(event)
+    {
+        case MEDIA_EVENT_CLICK_LINK_NOFOLLOW:
+        {
+            LL_DEBUGS("Media") << "MEDIA_EVENT_CLICK_LINK_NOFOLLOW, uri is: " << plugin->getClickURL() << LL_ENDL;
+            std::string url = plugin->getClickURL();
+            std::string nav_type = plugin->getClickNavType();
+            LLURLDispatcher::dispatch(url, nav_type, NULL, mTrustedBrowser);
+        }
+        break;
+        case MEDIA_EVENT_CLICK_LINK_HREF:
+        {
+            LL_DEBUGS("Media") <<  "Media event:  MEDIA_EVENT_CLICK_LINK_HREF, target is \"" << plugin->getClickTarget() << "\", uri is " << plugin->getClickURL() << LL_ENDL;
+        };
+        break;
+        case MEDIA_EVENT_PLUGIN_FAILED_LAUNCH:
+        {
+            // The plugin failed to load properly.  Make sure the timer doesn't retry.
+            // TODO: maybe mark this plugin as not loadable somehow?
+            mMediaSourceFailed = true;
+
+            // Reset the last known state of the media to defaults.
+            resetPreviousMediaState();
+
+            // TODO: may want a different message for this case?
+            LLSD args;
+            args["PLUGIN"] = LLMIMETypes::implType(mCurrentMimeType);
+            LLNotificationsUtil::add("MediaPluginFailed", args);
+        }
+        break;
+
+        case MEDIA_EVENT_PLUGIN_FAILED:
+        {
+            // The plugin crashed.
+            mMediaSourceFailed = true;
+
+            // Reset the last known state of the media to defaults.
+            resetPreviousMediaState();
+
+            LLSD args;
+            args["PLUGIN"] = LLMIMETypes::implType(mCurrentMimeType);
+            // SJB: This is getting called every frame if the plugin fails to load, continuously respawining the alert!
+            //LLNotificationsUtil::add("MediaPluginFailed", args);
+        }
+        break;
+
+        case MEDIA_EVENT_CURSOR_CHANGED:
+        {
+            LL_DEBUGS("Media") <<  "Media event:  MEDIA_EVENT_CURSOR_CHANGED, new cursor is " << plugin->getCursorName() << LL_ENDL;
+
+            std::string cursor = plugin->getCursorName();
+            mLastSetCursor = getCursorFromString(cursor);
+        }
+        break;
+
+        case LLViewerMediaObserver::MEDIA_EVENT_FILE_DOWNLOAD:
+        {
+            LL_DEBUGS("Media") << "Media event - file download requested - filename is " << plugin->getFileDownloadFilename() << LL_ENDL;
+        }
+        break;
+
+        case LLViewerMediaObserver::MEDIA_EVENT_NAVIGATE_BEGIN:
+        {
+            LL_DEBUGS("Media") << "MEDIA_EVENT_NAVIGATE_BEGIN, uri is: " << plugin->getNavigateURI() << LL_ENDL;
+            hideNotification();
+
+            if(getNavState() == MEDIANAVSTATE_SERVER_SENT)
+            {
+                setNavState(MEDIANAVSTATE_SERVER_BEGUN);
+            }
+            else
+            {
+                setNavState(MEDIANAVSTATE_BEGUN);
+            }
+        }
+        break;
+
+        case LLViewerMediaObserver::MEDIA_EVENT_NAVIGATE_COMPLETE:
+        {
+            LL_DEBUGS("Media") << "MEDIA_EVENT_NAVIGATE_COMPLETE, uri is: " << plugin->getNavigateURI() << LL_ENDL;
+
+            std::string url = plugin->getNavigateURI();
+            if(getNavState() == MEDIANAVSTATE_BEGUN)
+            {
+                if(mCurrentMediaURL == url)
+                {
+                    // This is a navigate that takes us to the same url as the previous navigate.
+                    setNavState(MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED_SPURIOUS);
+                }
+                else
+                {
+                    mCurrentMediaURL = url;
+                    setNavState(MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED);
+                }
+            }
+            else if(getNavState() == MEDIANAVSTATE_SERVER_BEGUN)
+            {
+                mCurrentMediaURL = url;
+                setNavState(MEDIANAVSTATE_SERVER_COMPLETE_BEFORE_LOCATION_CHANGED);
+            }
+            else
+            {
+                // all other cases need to leave the state alone.
+            }
+        }
+        break;
+
+        case LLViewerMediaObserver::MEDIA_EVENT_LOCATION_CHANGED:
+        {
+            LL_DEBUGS("Media") << "MEDIA_EVENT_LOCATION_CHANGED, uri is: " << plugin->getLocation() << LL_ENDL;
+
+            std::string url = plugin->getLocation();
+
+            if(getNavState() == MEDIANAVSTATE_BEGUN)
+            {
+                if(mCurrentMediaURL == url)
+                {
+                    // This is a navigate that takes us to the same url as the previous navigate.
+                    setNavState(MEDIANAVSTATE_FIRST_LOCATION_CHANGED_SPURIOUS);
+                }
+                else
+                {
+                    mCurrentMediaURL = url;
+                    setNavState(MEDIANAVSTATE_FIRST_LOCATION_CHANGED);
+                }
+            }
+            else if(getNavState() == MEDIANAVSTATE_SERVER_BEGUN)
+            {
+                mCurrentMediaURL = url;
+                setNavState(MEDIANAVSTATE_SERVER_FIRST_LOCATION_CHANGED);
+            }
+            else
+            {
+                bool internal_nav = false;
+                if (url != mCurrentMediaURL)
+                {
+                    // Check if it is internal navigation
+                    // Note: Not sure if we should detect internal navigations as 'address change',
+                    // but they are not redirects and do not cause NAVIGATE_BEGIN (also see SL-1005)
+                    size_t pos = url.find("#");
+                    if (pos != std::string::npos)
+                    {
+                        // assume that new link always have '#', so this is either
+                        // transfer from 'link#1' to 'link#2' or from link to 'link#2'
+                        // filter out cases like 'redirect?link'
+                        std::string base_url = url.substr(0, pos);
+                        pos = mCurrentMediaURL.find(base_url);
+                        if (pos == 0)
+                        {
+                            // base link hasn't changed
+                            internal_nav = true;
+                        }
+                    }
+                }
+
+                if (internal_nav)
+                {
+                    // Internal navigation by '#'
+                    mCurrentMediaURL = url;
+                    setNavState(MEDIANAVSTATE_FIRST_LOCATION_CHANGED);
+                }
+                else
+                {
+                    // Don't track redirects.
+                    setNavState(MEDIANAVSTATE_NONE);
+                }
+            }
+        }
+        break;
+
+        case LLViewerMediaObserver::MEDIA_EVENT_PICK_FILE_REQUEST:
+        {
+            LL_DEBUGS("Media") << "Media event - file pick requested." <<  LL_ENDL;
+
+            init_threaded_picker_load_dialog(plugin, LLFilePicker::FFLOAD_ALL, plugin->getIsMultipleFilePick());
+        }
+        break;
+
+        case LLViewerMediaObserver::MEDIA_EVENT_AUTH_REQUEST:
+        {
+            LLNotification::Params auth_request_params;
+            auth_request_params.name = "AuthRequest";
+
+            // pass in host name and realm for site (may be zero length but will always exist)
+            LLSD args;
+            LLURL raw_url( plugin->getAuthURL().c_str() );
+            args["HOST_NAME"] = raw_url.getAuthority();
+            args["REALM"] = plugin->getAuthRealm();
+            auth_request_params.substitutions = args;
+
+            auth_request_params.payload = LLSD().with("media_id", mTextureId);
+            auth_request_params.functor.function = boost::bind(&LLViewerMedia::authSubmitCallback, _1, _2);
+            LLNotifications::instance().add(auth_request_params);
+        };
+        break;
+
+        case LLViewerMediaObserver::MEDIA_EVENT_CLOSE_REQUEST:
+        {
+            std::string uuid = plugin->getClickUUID();
+
+            LL_INFOS() << "MEDIA_EVENT_CLOSE_REQUEST for uuid " << uuid << LL_ENDL;
+
+            if(uuid.empty())
+            {
+                // This close request is directed at this instance, let it fall through.
+            }
+            else
+            {
+                // This close request is directed at another instance
+                pass_through = false;
+                LLFloaterWebContent::closeRequest(uuid);
+            }
+        }
+        break;
+
+        case LLViewerMediaObserver::MEDIA_EVENT_GEOMETRY_CHANGE:
+        {
+            std::string uuid = plugin->getClickUUID();
+
+            LL_INFOS() << "MEDIA_EVENT_GEOMETRY_CHANGE for uuid " << uuid << LL_ENDL;
+
+            if(uuid.empty())
+            {
+                // This geometry change request is directed at this instance, let it fall through.
+            }
+            else
+            {
+                // This request is directed at another instance
+                pass_through = false;
+                LLFloaterWebContent::geometryChanged(uuid, plugin->getGeometryX(), plugin->getGeometryY(), plugin->getGeometryWidth(), plugin->getGeometryHeight());
+            }
+        }
+        break;
+
+        default:
+        break;
+    }
+
+    if(pass_through)
+    {
+        // Just chain the event to observers.
+        emitEvent(plugin, event);
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -3492,8 +3492,8 @@ void LLViewerMediaImpl::handleMediaEvent(LLPluginClassMedia* plugin, LLPluginCla
 void
 LLViewerMediaImpl::cut()
 {
-	if (mMediaSource)
-		mMediaSource->cut();
+    if (mMediaSource)
+        mMediaSource->cut();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -3501,10 +3501,10 @@ LLViewerMediaImpl::cut()
 bool
 LLViewerMediaImpl::canCut() const
 {
-	if (mMediaSource)
-		return mMediaSource->canCut();
-	else
-		return false;
+    if (mMediaSource)
+        return mMediaSource->canCut();
+    else
+        return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -3512,8 +3512,8 @@ LLViewerMediaImpl::canCut() const
 void
 LLViewerMediaImpl::copy()
 {
-	if (mMediaSource)
-		mMediaSource->copy();
+    if (mMediaSource)
+        mMediaSource->copy();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -3521,10 +3521,10 @@ LLViewerMediaImpl::copy()
 bool
 LLViewerMediaImpl::canCopy() const
 {
-	if (mMediaSource)
-		return mMediaSource->canCopy();
-	else
-		return false;
+    if (mMediaSource)
+        return mMediaSource->canCopy();
+    else
+        return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -3532,8 +3532,8 @@ LLViewerMediaImpl::canCopy() const
 void
 LLViewerMediaImpl::paste()
 {
-	if (mMediaSource)
-		mMediaSource->paste();
+    if (mMediaSource)
+        mMediaSource->paste();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -3541,20 +3541,20 @@ LLViewerMediaImpl::paste()
 bool
 LLViewerMediaImpl::canPaste() const
 {
-	if (mMediaSource)
-		return mMediaSource->canPaste();
-	else
-		return false;
+    if (mMediaSource)
+        return mMediaSource->canPaste();
+    else
+        return false;
 }
 
 void LLViewerMediaImpl::setUpdated(bool updated)
 {
-	mIsUpdated = updated ;
+    mIsUpdated = updated ;
 }
 
 bool LLViewerMediaImpl::isUpdated()
 {
-	return mIsUpdated ;
+    return mIsUpdated ;
 }
 
 static LLTrace::BlockTimerStatHandle FTM_MEDIA_CALCULATE_INTEREST("Calculate Interest");
@@ -3562,37 +3562,37 @@ static LLTrace::BlockTimerStatHandle FTM_MEDIA_CALCULATE_INTEREST("Calculate Int
 void LLViewerMediaImpl::calculateInterest()
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_MEDIA; //LL_RECORD_BLOCK_TIME(FTM_MEDIA_CALCULATE_INTEREST);
-	LLViewerMediaTexture* texture = LLViewerTextureManager::findMediaTexture( mTextureId );
+    LLViewerMediaTexture* texture = LLViewerTextureManager::findMediaTexture( mTextureId );
 
     llassert(!gCubeSnapshot);
 
-	if(texture != NULL)
-	{
-		mInterest = texture->getMaxVirtualSize();
-	}
-	else
-	{
-		// This will be a relatively common case now, since it will always be true for unloaded media.
-		mInterest = 0.0f;
-	}
-
-	// Calculate distance from the avatar, for use in the proximity calculation.
-	mProximityDistance = 0.0f;
-	mProximityCamera = 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.
-		std::list< LLVOVolume* >::iterator iter = mObjectList.begin() ;
-		LLVOVolume* objp = *iter ;
-		llassert_always(objp != NULL) ;
-
-		// The distance calculation is invalid for HUD attachments -- leave both mProximityDistance and mProximityCamera at 0 for them.
-		if(!objp->isHUDAttachment())
-		{
-			LLVector3d obj_global = objp->getPositionGlobal() ;
-			LLVector3d agent_global = gAgent.getPositionGlobal() ;
-			LLVector3d global_delta = agent_global - obj_global ;
-			mProximityDistance = global_delta.magVecSquared();  // use distance-squared because it's cheaper and sorts the same.
+    if(texture != NULL)
+    {
+        mInterest = texture->getMaxVirtualSize();
+    }
+    else
+    {
+        // This will be a relatively common case now, since it will always be true for unloaded media.
+        mInterest = 0.0f;
+    }
+
+    // Calculate distance from the avatar, for use in the proximity calculation.
+    mProximityDistance = 0.0f;
+    mProximityCamera = 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.
+        std::list< LLVOVolume* >::iterator iter = mObjectList.begin() ;
+        LLVOVolume* objp = *iter ;
+        llassert_always(objp != NULL) ;
+
+        // The distance calculation is invalid for HUD attachments -- leave both mProximityDistance and mProximityCamera at 0 for them.
+        if(!objp->isHUDAttachment())
+        {
+            LLVector3d obj_global = objp->getPositionGlobal() ;
+            LLVector3d agent_global = gAgent.getPositionGlobal() ;
+            LLVector3d global_delta = agent_global - obj_global ;
+            mProximityDistance = global_delta.magVecSquared();  // use distance-squared because it's cheaper and sorts the same.
 
             static LLUICachedControl<S32> mEarLocation("MediaSoundsEarLocation", 0);
             LLVector3d ear_position;
@@ -3608,185 +3608,185 @@ void LLViewerMediaImpl::calculateInterest()
                 break;
             }
             LLVector3d camera_delta = ear_position - obj_global;
-			mProximityCamera = camera_delta.magVec();
-		}
-	}
-
-	if(mNeedsMuteCheck)
-	{
-		// Check all objects this instance is associated with, and those objects' owners, against the mute list
-		mIsMuted = false;
-
-		std::list< LLVOVolume* >::iterator iter = mObjectList.begin() ;
-		for(; iter != mObjectList.end() ; ++iter)
-		{
-			LLVOVolume *obj = *iter;
-			llassert(obj);
-			if (!obj) continue;
-			if(LLMuteList::getInstance() &&
-			   LLMuteList::getInstance()->isMuted(obj->getID()))
-			{
-				mIsMuted = true;
-			}
-			else
-			{
-				// We won't have full permissions data for all objects.  Attempt to mute objects when we can tell their owners are muted.
-				if (LLSelectMgr::getInstance())
-				{
-					LLPermissions* obj_perm = LLSelectMgr::getInstance()->findObjectPermissions(obj);
-					if(obj_perm)
-					{
-						if(LLMuteList::getInstance() &&
-						   LLMuteList::getInstance()->isMuted(obj_perm->getOwner()))
-							mIsMuted = true;
-					}
-				}
-			}
-		}
-
-		mNeedsMuteCheck = false;
-	}
+            mProximityCamera = camera_delta.magVec();
+        }
+    }
+
+    if(mNeedsMuteCheck)
+    {
+        // Check all objects this instance is associated with, and those objects' owners, against the mute list
+        mIsMuted = false;
+
+        std::list< LLVOVolume* >::iterator iter = mObjectList.begin() ;
+        for(; iter != mObjectList.end() ; ++iter)
+        {
+            LLVOVolume *obj = *iter;
+            llassert(obj);
+            if (!obj) continue;
+            if(LLMuteList::getInstance() &&
+               LLMuteList::getInstance()->isMuted(obj->getID()))
+            {
+                mIsMuted = true;
+            }
+            else
+            {
+                // We won't have full permissions data for all objects.  Attempt to mute objects when we can tell their owners are muted.
+                if (LLSelectMgr::getInstance())
+                {
+                    LLPermissions* obj_perm = LLSelectMgr::getInstance()->findObjectPermissions(obj);
+                    if(obj_perm)
+                    {
+                        if(LLMuteList::getInstance() &&
+                           LLMuteList::getInstance()->isMuted(obj_perm->getOwner()))
+                            mIsMuted = true;
+                    }
+                }
+            }
+        }
+
+        mNeedsMuteCheck = false;
+    }
 }
 
 F64 LLViewerMediaImpl::getApproximateTextureInterest()
 {
-	F64 result = 0.0f;
+    F64 result = 0.0f;
 
-	if(mMediaSource)
-	{
-		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;
-	}
+    if(mMediaSource)
+    {
+        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;
+    return result;
 }
 
 void LLViewerMediaImpl::setUsedInUI(bool used_in_ui)
 {
-	mUsedInUI = used_in_ui;
-
-	// HACK: Force elements used in UI to load right away.
-	// This fixes some issues where UI code that uses the browser instance doesn't expect it to be unloaded.
-	if(mUsedInUI && (mPriority == LLPluginClassMedia::PRIORITY_UNLOADED))
-	{
-		if(getVisible())
-		{
-			setPriority(LLPluginClassMedia::PRIORITY_NORMAL);
-		}
-		else
-		{
-			setPriority(LLPluginClassMedia::PRIORITY_HIDDEN);
-		}
-
-		createMediaSource();
-	}
+    mUsedInUI = used_in_ui;
+
+    // HACK: Force elements used in UI to load right away.
+    // This fixes some issues where UI code that uses the browser instance doesn't expect it to be unloaded.
+    if(mUsedInUI && (mPriority == LLPluginClassMedia::PRIORITY_UNLOADED))
+    {
+        if(getVisible())
+        {
+            setPriority(LLPluginClassMedia::PRIORITY_NORMAL);
+        }
+        else
+        {
+            setPriority(LLPluginClassMedia::PRIORITY_HIDDEN);
+        }
+
+        createMediaSource();
+    }
 };
 
 void LLViewerMediaImpl::setBackgroundColor(LLColor4 color)
 {
-	mBackgroundColor = color;
+    mBackgroundColor = color;
 
-	if(mMediaSource)
-	{
-		mMediaSource->setBackgroundColor(mBackgroundColor);
-	}
+    if(mMediaSource)
+    {
+        mMediaSource->setBackgroundColor(mBackgroundColor);
+    }
 };
 
 F64 LLViewerMediaImpl::getCPUUsage() const
 {
-	F64 result = 0.0f;
+    F64 result = 0.0f;
 
-	if(mMediaSource)
-	{
-		result = mMediaSource->getCPUUsage();
-	}
+    if(mMediaSource)
+    {
+        result = mMediaSource->getCPUUsage();
+    }
 
-	return result;
+    return result;
 }
 
 void LLViewerMediaImpl::setPriority(LLPluginClassMedia::EPriority priority)
 {
-	if(mPriority != priority)
-	{
-		LL_DEBUGS("PluginPriority")
-			<< "changing priority of media id " << mTextureId
-			<< " from " << LLPluginClassMedia::priorityToString(mPriority)
-			<< " to " << LLPluginClassMedia::priorityToString(priority)
-			<< LL_ENDL;
-	}
+    if(mPriority != priority)
+    {
+        LL_DEBUGS("PluginPriority")
+            << "changing priority of media id " << mTextureId
+            << " from " << LLPluginClassMedia::priorityToString(mPriority)
+            << " to " << LLPluginClassMedia::priorityToString(priority)
+            << LL_ENDL;
+    }
 
-	mPriority = priority;
+    mPriority = priority;
 
-	if(priority == LLPluginClassMedia::PRIORITY_UNLOADED)
-	{
-		if(mMediaSource)
-		{
-			// Need to unload the media source
+    if(priority == LLPluginClassMedia::PRIORITY_UNLOADED)
+    {
+        if(mMediaSource)
+        {
+            // Need to unload the media source
 
-			// First, save off previous media state
-			mPreviousMediaState = mMediaSource->getStatus();
-			mPreviousMediaTime = mMediaSource->getCurrentTime();
+            // First, save off previous media state
+            mPreviousMediaState = mMediaSource->getStatus();
+            mPreviousMediaTime = mMediaSource->getCurrentTime();
 
-			destroyMediaSource();
-		}
-	}
+            destroyMediaSource();
+        }
+    }
 
-	if(mMediaSource)
-	{
-		mMediaSource->setPriority(mPriority);
-	}
+    if(mMediaSource)
+    {
+        mMediaSource->setPriority(mPriority);
+    }
 
-	// NOTE: loading (or reloading) media sources whose priority has risen above PRIORITY_UNLOADED is done in update().
+    // NOTE: loading (or reloading) media sources whose priority has risen above PRIORITY_UNLOADED is done in update().
 }
 
 void LLViewerMediaImpl::setLowPrioritySizeLimit(int size)
 {
-	if(mMediaSource)
-	{
-		mMediaSource->setLowPrioritySizeLimit(size);
-	}
+    if(mMediaSource)
+    {
+        mMediaSource->setLowPrioritySizeLimit(size);
+    }
 }
 
 void LLViewerMediaImpl::setNavState(EMediaNavState state)
 {
-	mMediaNavState = state;
+    mMediaNavState = state;
 
-	switch (state)
-	{
-		case MEDIANAVSTATE_NONE: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_NONE" << LL_ENDL; break;
-		case MEDIANAVSTATE_BEGUN: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_BEGUN" << LL_ENDL; break;
-		case MEDIANAVSTATE_FIRST_LOCATION_CHANGED: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_FIRST_LOCATION_CHANGED" << LL_ENDL; break;
-		case MEDIANAVSTATE_FIRST_LOCATION_CHANGED_SPURIOUS: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_FIRST_LOCATION_CHANGED_SPURIOUS" << LL_ENDL; break;
-		case MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED" << LL_ENDL; break;
-		case MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED_SPURIOUS: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED_SPURIOUS" << LL_ENDL; break;
-		case MEDIANAVSTATE_SERVER_SENT: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_SERVER_SENT" << LL_ENDL; break;
-		case MEDIANAVSTATE_SERVER_BEGUN: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_SERVER_BEGUN" << LL_ENDL; break;
-		case MEDIANAVSTATE_SERVER_FIRST_LOCATION_CHANGED: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_SERVER_FIRST_LOCATION_CHANGED" << LL_ENDL; break;
-		case MEDIANAVSTATE_SERVER_COMPLETE_BEFORE_LOCATION_CHANGED: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_SERVER_COMPLETE_BEFORE_LOCATION_CHANGED" << LL_ENDL; break;
-	}
+    switch (state)
+    {
+        case MEDIANAVSTATE_NONE: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_NONE" << LL_ENDL; break;
+        case MEDIANAVSTATE_BEGUN: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_BEGUN" << LL_ENDL; break;
+        case MEDIANAVSTATE_FIRST_LOCATION_CHANGED: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_FIRST_LOCATION_CHANGED" << LL_ENDL; break;
+        case MEDIANAVSTATE_FIRST_LOCATION_CHANGED_SPURIOUS: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_FIRST_LOCATION_CHANGED_SPURIOUS" << LL_ENDL; break;
+        case MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED" << LL_ENDL; break;
+        case MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED_SPURIOUS: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED_SPURIOUS" << LL_ENDL; break;
+        case MEDIANAVSTATE_SERVER_SENT: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_SERVER_SENT" << LL_ENDL; break;
+        case MEDIANAVSTATE_SERVER_BEGUN: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_SERVER_BEGUN" << LL_ENDL; break;
+        case MEDIANAVSTATE_SERVER_FIRST_LOCATION_CHANGED: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_SERVER_FIRST_LOCATION_CHANGED" << LL_ENDL; break;
+        case MEDIANAVSTATE_SERVER_COMPLETE_BEFORE_LOCATION_CHANGED: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_SERVER_COMPLETE_BEFORE_LOCATION_CHANGED" << LL_ENDL; break;
+    }
 }
 
 void LLViewerMediaImpl::setNavigateSuspended(bool suspend)
 {
-	if(mNavigateSuspended != suspend)
-	{
-		mNavigateSuspended = suspend;
-		if(!suspend)
-		{
-			// We're coming out of suspend.  If someone tried to do a navigate while suspended, do one now instead.
-			if(mNavigateSuspendedDeferred)
-			{
-				mNavigateSuspendedDeferred = false;
-				navigateInternal();
-			}
-		}
-	}
+    if(mNavigateSuspended != suspend)
+    {
+        mNavigateSuspended = suspend;
+        if(!suspend)
+        {
+            // We're coming out of suspend.  If someone tried to do a navigate while suspended, do one now instead.
+            if(mNavigateSuspendedDeferred)
+            {
+                mNavigateSuspendedDeferred = false;
+                navigateInternal();
+            }
+        }
+    }
 }
 
 void LLViewerMediaImpl::cancelMimeTypeProbe()
@@ -3795,114 +3795,114 @@ void LLViewerMediaImpl::cancelMimeTypeProbe()
 
     if (probeAdapter)
         probeAdapter->cancelSuspendedOperation();
-		
+
 }
 
 void LLViewerMediaImpl::addObject(LLVOVolume* obj)
 {
-	std::list< LLVOVolume* >::iterator iter = mObjectList.begin() ;
-	for(; iter != mObjectList.end() ; ++iter)
-	{
-		if(*iter == obj)
-		{
-			return ; //already in the list.
-		}
-	}
+    std::list< LLVOVolume* >::iterator iter = mObjectList.begin() ;
+    for(; iter != mObjectList.end() ; ++iter)
+    {
+        if(*iter == obj)
+        {
+            return ; //already in the list.
+        }
+    }
 
-	mObjectList.push_back(obj) ;
-	mNeedsMuteCheck = true;
+    mObjectList.push_back(obj) ;
+    mNeedsMuteCheck = true;
 }
 
 void LLViewerMediaImpl::removeObject(LLVOVolume* obj)
 {
-	mObjectList.remove(obj) ;
-	mNeedsMuteCheck = true;
+    mObjectList.remove(obj) ;
+    mNeedsMuteCheck = true;
 }
 
 const std::list< LLVOVolume* >* LLViewerMediaImpl::getObjectList() const
 {
-	return &mObjectList ;
+    return &mObjectList ;
 }
 
 LLVOVolume *LLViewerMediaImpl::getSomeObject()
 {
-	LLVOVolume *result = NULL;
+    LLVOVolume *result = NULL;
 
-	std::list< LLVOVolume* >::iterator iter = mObjectList.begin() ;
-	if(iter != mObjectList.end())
-	{
-		result = *iter;
-	}
+    std::list< LLVOVolume* >::iterator iter = mObjectList.begin() ;
+    if(iter != mObjectList.end())
+    {
+        result = *iter;
+    }
 
-	return result;
+    return result;
 }
 
 void LLViewerMediaImpl::setTextureID(LLUUID id)
 {
-	if(id != mTextureId)
-	{
-		if(mTextureId.notNull())
-		{
-			// Remove this item's entry from the map
-			sViewerMediaTextureIDMap.erase(mTextureId);
-		}
+    if(id != mTextureId)
+    {
+        if(mTextureId.notNull())
+        {
+            // Remove this item's entry from the map
+            sViewerMediaTextureIDMap.erase(mTextureId);
+        }
 
-		if(id.notNull())
-		{
-			sViewerMediaTextureIDMap.insert(LLViewerMedia::impl_id_map::value_type(id, this));
-		}
+        if(id.notNull())
+        {
+            sViewerMediaTextureIDMap.insert(LLViewerMedia::impl_id_map::value_type(id, this));
+        }
 
-		mTextureId = id;
-	}
+        mTextureId = id;
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 //
 bool LLViewerMediaImpl::isAutoPlayable() const
 {
-	return (mMediaAutoPlay &&
-			gSavedSettings.getS32("ParcelMediaAutoPlayEnable") != 0 &&
-			gSavedSettings.getBOOL("MediaTentativeAutoPlay"));
+    return (mMediaAutoPlay &&
+            gSavedSettings.getS32("ParcelMediaAutoPlayEnable") != 0 &&
+            gSavedSettings.getBOOL("MediaTentativeAutoPlay"));
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 //
 bool LLViewerMediaImpl::shouldShowBasedOnClass() const
 {
-	// If this is parcel media or in the UI, return true always
-	if (getUsedInUI() || isParcelMedia()) return true;
+    // If this is parcel media or in the UI, return true always
+    if (getUsedInUI() || isParcelMedia()) return true;
 
-	bool attached_to_another_avatar = isAttachedToAnotherAvatar();
-	bool inside_parcel = isInAgentParcel();
+    bool attached_to_another_avatar = isAttachedToAnotherAvatar();
+    bool inside_parcel = isInAgentParcel();
 
-	//	LL_INFOS() << " hasFocus = " << hasFocus() <<
-	//	" others = " << (attached_to_another_avatar && gSavedSettings.getBOOL(LLViewerMedia::SHOW_MEDIA_ON_OTHERS_SETTING)) <<
-	//	" within = " << (inside_parcel && gSavedSettings.getBOOL(LLViewerMedia::SHOW_MEDIA_WITHIN_PARCEL_SETTING)) <<
-	//	" outside = " << (!inside_parcel && gSavedSettings.getBOOL(LLViewerMedia::SHOW_MEDIA_OUTSIDE_PARCEL_SETTING)) << LL_ENDL;
+    //  LL_INFOS() << " hasFocus = " << hasFocus() <<
+    //  " others = " << (attached_to_another_avatar && gSavedSettings.getBOOL(LLViewerMedia::SHOW_MEDIA_ON_OTHERS_SETTING)) <<
+    //  " within = " << (inside_parcel && gSavedSettings.getBOOL(LLViewerMedia::SHOW_MEDIA_WITHIN_PARCEL_SETTING)) <<
+    //  " outside = " << (!inside_parcel && gSavedSettings.getBOOL(LLViewerMedia::SHOW_MEDIA_OUTSIDE_PARCEL_SETTING)) << LL_ENDL;
 
-	// If it has focus, we should show it
-	// This is incorrect, and causes EXT-6750 (disabled attachment media still plays)
-//	if (hasFocus())
-//		return true;
+    // If it has focus, we should show it
+    // This is incorrect, and causes EXT-6750 (disabled attachment media still plays)
+//  if (hasFocus())
+//      return true;
 
-	// If it is attached to an avatar and the pref is off, we shouldn't show it
-	if (attached_to_another_avatar)
-	{
-		static LLCachedControl<bool> show_media_on_others(gSavedSettings, LLViewerMedia::SHOW_MEDIA_ON_OTHERS_SETTING, false);
-		return show_media_on_others;
-	}
-	if (inside_parcel)
-	{
-		static LLCachedControl<bool> show_media_within_parcel(gSavedSettings, LLViewerMedia::SHOW_MEDIA_WITHIN_PARCEL_SETTING, true);
+    // If it is attached to an avatar and the pref is off, we shouldn't show it
+    if (attached_to_another_avatar)
+    {
+        static LLCachedControl<bool> show_media_on_others(gSavedSettings, LLViewerMedia::SHOW_MEDIA_ON_OTHERS_SETTING, false);
+        return show_media_on_others;
+    }
+    if (inside_parcel)
+    {
+        static LLCachedControl<bool> show_media_within_parcel(gSavedSettings, LLViewerMedia::SHOW_MEDIA_WITHIN_PARCEL_SETTING, true);
 
-		return show_media_within_parcel;
-	}
-	else
-	{
-		static LLCachedControl<bool> show_media_outside_parcel(gSavedSettings, LLViewerMedia::SHOW_MEDIA_OUTSIDE_PARCEL_SETTING, true);
+        return show_media_within_parcel;
+    }
+    else
+    {
+        static LLCachedControl<bool> show_media_outside_parcel(gSavedSettings, LLViewerMedia::SHOW_MEDIA_OUTSIDE_PARCEL_SETTING, true);
 
-		return show_media_outside_parcel;
-	}
+        return show_media_outside_parcel;
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -3916,7 +3916,7 @@ bool LLViewerMediaImpl::isObscured() const
     {
         return false;
     }
-    
+
     if (agent_parcel->getObscureMOAP() && !isInAgentParcel())
     {
         return true;
@@ -3943,19 +3943,19 @@ bool LLViewerMediaImpl::isAttachedToHUD() const
 //
 bool LLViewerMediaImpl::isAttachedToAnotherAvatar() const
 {
-	bool result = false;
+    bool result = false;
 
-	std::list< LLVOVolume* >::const_iterator iter = mObjectList.begin();
-	std::list< LLVOVolume* >::const_iterator end = mObjectList.end();
-	for ( ; iter != end; iter++)
-	{
-		if (isObjectAttachedToAnotherAvatar(*iter))
-		{
-			result = true;
-			break;
-		}
-	}
-	return result;
+    std::list< LLVOVolume* >::const_iterator iter = mObjectList.begin();
+    std::list< LLVOVolume* >::const_iterator end = mObjectList.end();
+    for ( ; iter != end; iter++)
+    {
+        if (isObjectAttachedToAnotherAvatar(*iter))
+        {
+            result = true;
+            break;
+        }
+    }
+    return result;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -3963,49 +3963,49 @@ bool LLViewerMediaImpl::isAttachedToAnotherAvatar() const
 //static
 bool LLViewerMediaImpl::isObjectAttachedToAnotherAvatar(LLVOVolume *obj)
 {
-	bool result = false;
-	LLXform *xform = obj;
-	// Walk up parent chain
-	while (NULL != xform)
-	{
-		LLViewerObject *object = dynamic_cast<LLViewerObject*> (xform);
-		if (NULL != object)
-		{
-			LLVOAvatar *avatar = object->asAvatar();
-			if ((NULL != avatar) && (avatar != gAgentAvatarp))
-			{
-				result = true;
-				break;
-			}
-		}
-		xform = xform->getParent();
-	}
-	return result;
+    bool result = false;
+    LLXform *xform = obj;
+    // Walk up parent chain
+    while (NULL != xform)
+    {
+        LLViewerObject *object = dynamic_cast<LLViewerObject*> (xform);
+        if (NULL != object)
+        {
+            LLVOAvatar *avatar = object->asAvatar();
+            if ((NULL != avatar) && (avatar != gAgentAvatarp))
+            {
+                result = true;
+                break;
+            }
+        }
+        xform = xform->getParent();
+    }
+    return result;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 //
 bool LLViewerMediaImpl::isInAgentParcel() const
 {
-	bool result = false;
+    bool result = false;
 
-	std::list< LLVOVolume* >::const_iterator iter = mObjectList.begin();
-	std::list< LLVOVolume* >::const_iterator end = mObjectList.end();
-	for ( ; iter != end; iter++)
-	{
-		LLVOVolume *object = *iter;
-		if (LLViewerMediaImpl::isObjectInAgentParcel(object))
-		{
-			result = true;
-			break;
-		}
-	}
-	return result;
+    std::list< LLVOVolume* >::const_iterator iter = mObjectList.begin();
+    std::list< LLVOVolume* >::const_iterator end = mObjectList.end();
+    for ( ; iter != end; iter++)
+    {
+        LLVOVolume *object = *iter;
+        if (LLViewerMediaImpl::isObjectInAgentParcel(object))
+        {
+            result = true;
+            break;
+        }
+    }
+    return result;
 }
 
 LLNotificationPtr LLViewerMediaImpl::getCurrentNotification() const
 {
-	return mNotification;
+    return mNotification;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -4013,5 +4013,5 @@ LLNotificationPtr LLViewerMediaImpl::getCurrentNotification() const
 // static
 bool LLViewerMediaImpl::isObjectInAgentParcel(LLVOVolume *obj)
 {
-	return (LLViewerParcelMgr::getInstance()->inAgentParcel(obj->getPositionGlobal()));
+    return (LLViewerParcelMgr::getInstance()->inAgentParcel(obj->getPositionGlobal()));
 }