livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

DRTVWR-493 LLViewerMedia to singleton

master
andreykproductengine 2019-06-21 20:55:39 +03:00
parent a2d91f3160
commit 8369276a49
24 changed files with 217 additions and 236 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
indra/newview/llappviewer.cpp
View File

@ -1211,9 +1211,6 @@ bool LLAppViewer::init()
<< LL_ENDL;
}
LLViewerMedia::initClass();
LL_INFOS("InitInfo") << "Viewer media initialized." << LL_ENDL ;
LLTextUtil::TextHelpers::iconCallbackCreationFunction = create_text_segment_icon_from_url_match;
//EXT-7013 - On windows for some locale (Japanese) standard
@ -2045,7 +2042,6 @@ bool LLAppViewer::cleanup()
//Note:
//SUBSYSTEM_CLEANUP(LLViewerMedia) has to be put before gTextureList.shutdown()
//because some new image might be generated during cleaning up media. --bao
SUBSYSTEM_CLEANUP(LLViewerMedia);
SUBSYSTEM_CLEANUP(LLViewerParcelMedia);
gTextureList.shutdown(); // shutdown again in case a callback added something
LLUIImageList::getInstance()->cleanUp();

2
indra/newview/llbrowsernotification.cpp
View File

@ -50,7 +50,7 @@ bool LLBrowserNotification::processNotification(const LLNotificationPtr& notific
}
else if (LLViewerMediaFocus::instance().getControlsMediaID() == media_id)
{
LLViewerMediaImpl* impl = LLViewerMedia::getMediaImplFromTextureID(media_id);
LLViewerMediaImpl* impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(media_id);
if (impl)
{
impl->showNotification(notification);

8
indra/newview/llfloaterpreference.cpp
View File

@ -254,8 +254,8 @@ bool callback_clear_browser_cache(const LLSD& notification, const LLSD& response
if ( option == 0 ) // YES
{
// clean web
LLViewerMedia::clearAllCaches();
LLViewerMedia::clearAllCookies();
LLViewerMedia::getInstance()->clearAllCaches();
LLViewerMedia::getInstance()->clearAllCookies();
// clean nav bar history
LLNavigationBar::getInstance()->clearHistoryCache();
@ -635,14 +635,14 @@ void LLFloaterPreference::apply()
std::string cache_location = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "");
setCacheLocation(cache_location);
LLViewerMedia::setCookiesEnabled(getChild<LLUICtrl>("cookies_enabled")->getValue());
LLViewerMedia::getInstance()->setCookiesEnabled(getChild<LLUICtrl>("cookies_enabled")->getValue());
if (hasChild("web_proxy_enabled", TRUE) &&hasChild("web_proxy_editor", TRUE) && hasChild("web_proxy_port", TRUE))
{
bool proxy_enable = getChild<LLUICtrl>("web_proxy_enabled")->getValue();
std::string proxy_address = getChild<LLUICtrl>("web_proxy_editor")->getValue();
int proxy_port = getChild<LLUICtrl>("web_proxy_port")->getValue();
LLViewerMedia::setProxyConfig(proxy_enable, proxy_address, proxy_port);
LLViewerMedia::getInstance()->setProxyConfig(proxy_enable, proxy_address, proxy_port);
}
if (mGotPersonalInfo)

4
indra/newview/llfloaterwebcontent.cpp
View File

@ -235,7 +235,7 @@ void LLFloaterWebContent::preCreate(LLFloaterWebContent::Params& p)
void LLFloaterWebContent::open_media(const Params& p)
{
LLViewerMedia::proxyWindowOpened(p.target(), p.id());
LLViewerMedia::getInstance()->proxyWindowOpened(p.target(), p.id());
mWebBrowser->setHomePageUrl(p.url);
mWebBrowser->setTarget(p.target);
mWebBrowser->navigateTo(p.url);
@ -319,7 +319,7 @@ void LLFloaterWebContent::onClose(bool app_quitting)
LLTwitterConnect::instance().setConnectionState(LLTwitterConnect::TWITTER_CONNECTION_FAILED);
}
}
LLViewerMedia::proxyWindowClosed(mUUID);
LLViewerMedia::getInstance()->proxyWindowClosed(mUUID);
destroy();
}

4
indra/newview/llinspectobject.cpp
View File

@ -241,7 +241,7 @@ void LLInspectObject::onOpen(const LLSD& data)
if(!mMediaEntry)
return;
mMediaImpl = LLViewerMedia::getMediaImplFromTextureID(mMediaEntry->getMediaID());
mMediaImpl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mMediaEntry->getMediaID());
}
}
@ -300,7 +300,7 @@ void LLInspectObject::update()
if(!mMediaEntry)
return;
mMediaImpl = LLViewerMedia::getMediaImplFromTextureID(mMediaEntry->getMediaID());
mMediaImpl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mMediaEntry->getMediaID());
updateMediaCurrentURL();
updateSecureBrowsing();

6
indra/newview/llmarketplacefunctions.cpp
View File

@ -219,7 +219,7 @@ namespace LLMarketplaceImport
httpHeaders->append(HTTP_OUT_HEADER_CONNECTION, "Keep-Alive");
httpHeaders->append(HTTP_OUT_HEADER_COOKIE, sMarketplaceCookie);
httpHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, HTTP_CONTENT_XML);
httpHeaders->append(HTTP_OUT_HEADER_USER_AGENT, LLViewerMedia::getCurrentUserAgent());
httpHeaders->append(HTTP_OUT_HEADER_USER_AGENT, LLViewerMedia::getInstance()->getCurrentUserAgent());
LLSD result = httpAdapter->postAndSuspend(httpRequest, url, LLSD(), httpOpts, httpHeaders);
@ -283,11 +283,11 @@ namespace LLMarketplaceImport
httpHeaders->append(HTTP_OUT_HEADER_ACCEPT, "*/*");
httpHeaders->append(HTTP_OUT_HEADER_COOKIE, sMarketplaceCookie);
httpHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, HTTP_CONTENT_LLSD_XML);
httpHeaders->append(HTTP_OUT_HEADER_USER_AGENT, LLViewerMedia::getCurrentUserAgent());
httpHeaders->append(HTTP_OUT_HEADER_USER_AGENT, LLViewerMedia::getInstance()->getCurrentUserAgent());
}
else
{
httpHeaders = LLViewerMedia::getHttpHeaders();
httpHeaders = LLViewerMedia::getInstance()->getHttpHeaders();
}
LLSD result = httpAdapter->getAndSuspend(httpRequest, url, httpOpts, httpHeaders);

6
indra/newview/llmediactrl.cpp
View File

@ -691,7 +691,7 @@ bool LLMediaCtrl::ensureMediaSourceExists()
if(mMediaSource.isNull())
{
// If we don't already have a media source, try to create one.
mMediaSource = LLViewerMedia::newMediaImpl(mMediaTextureID, mTextureWidth, mTextureHeight);
mMediaSource = LLViewerMedia::getInstance()->newMediaImpl(mMediaTextureID, mTextureWidth, mTextureHeight);
if ( mMediaSource )
{
mMediaSource->setUsedInUI(true);
@ -1098,7 +1098,7 @@ void LLMediaCtrl::handleMediaEvent(LLPluginClassMedia* self, EMediaEvent event)
auth_request_params.substitutions = args;
auth_request_params.payload = LLSD().with("media_id", mMediaTextureID);
auth_request_params.functor.function = boost::bind(&LLViewerMedia::onAuthSubmit, _1, _2);
auth_request_params.functor.function = boost::bind(&LLViewerMedia::authSubmitCallback, _1, _2);
LLNotifications::instance().add(auth_request_params);
};
break;
@ -1144,7 +1144,7 @@ void LLMediaCtrl::onPopup(const LLSD& notification, const LLSD& response)
else
{
// Make sure the opening instance knows its window open request was denied, so it can clean things up.
LLViewerMedia::proxyWindowClosed(notification["payload"]["uuid"]);
LLViewerMedia::getInstance()->proxyWindowClosed(notification["payload"]["uuid"]);
}
}

8
indra/newview/llpanelface.cpp
View File

@ -886,7 +886,7 @@ void LLPanelFace::updateUI(bool force_set_values /*false*/)
break;
}
if(LLViewerMedia::textureHasMedia(id))
if(LLViewerMedia::getInstance()->textureHasMedia(id))
{
getChildView("button align")->setEnabled(editable);
}
@ -2367,13 +2367,13 @@ struct LLPanelFaceSetMediaFunctor : public LLSelectedTEFunctor
const LLMediaEntry* mep = tep->hasMedia() ? tep->getMediaData() : NULL;
if ( mep )
{
pMediaImpl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
pMediaImpl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mep->getMediaID());
}
if ( pMediaImpl.isNull())
{
// If we didn't find face media for this face, check whether this face is showing parcel media.
pMediaImpl = LLViewerMedia::getMediaImplFromTextureID(tep->getID());
pMediaImpl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(tep->getID());
}
if ( pMediaImpl.notNull())
@ -2526,7 +2526,7 @@ void LLPanelFace::LLSelectedTE::getTexId(LLUUID& id, bool& identical)
id = image->getID();
}
if (!id.isNull() && LLViewerMedia::textureHasMedia(id))
if (!id.isNull() && LLViewerMedia::getInstance()->textureHasMedia(id))
{
LLTextureEntry *te = object->getTE(te_index);
if (te)

2
indra/newview/llpanelmediasettingsgeneral.cpp
View File

@ -457,7 +457,7 @@ bool LLPanelMediaSettingsGeneral::navigateHomeSelectedFace(bool only_if_current_
if (!only_if_current_is_empty || (media_data->getCurrentURL().empty() && media_data->getAutoPlay()))
{
viewer_media_t media_impl =
LLViewerMedia::getMediaImplFromTextureID(object->getTE(face)->getMediaData()->getMediaID());
LLViewerMedia::getInstance()->getMediaImplFromTextureID(object->getTE(face)->getMediaData()->getMediaID());
if(media_impl)
{
media_impl->navigateHome();

55
indra/newview/llpanelnearbymedia.cpp
View File

@ -543,9 +543,10 @@ void LLPanelNearByMedia::refreshParcelItems()
// Only show "special parcel items" if "All" or "Within" filter
// (and if media is "enabled")
bool should_include = (choice == MEDIA_CLASS_ALL || choice == MEDIA_CLASS_WITHIN_PARCEL);
LLViewerMedia* media_inst = LLViewerMedia::getInstance();
// First Parcel Media: add or remove it as necessary
if (gSavedSettings.getBOOL("AudioStreamingMedia") &&should_include && LLViewerMedia::hasParcelMedia())
if (gSavedSettings.getBOOL("AudioStreamingMedia") && should_include && media_inst->hasParcelMedia())
{
// Yes, there is parcel media.
if (NULL == mParcelMediaItem)
@ -588,7 +589,7 @@ void LLPanelNearByMedia::refreshParcelItems()
}
// Next Parcel Audio: add or remove it as necessary (don't show if disabled in prefs)
if (should_include && LLViewerMedia::hasParcelAudio() && gSavedSettings.getBOOL("AudioStreamingMusic"))
if (should_include && media_inst->hasParcelAudio() && gSavedSettings.getBOOL("AudioStreamingMusic"))
{
// Yes, there is parcel audio.
if (NULL == mParcelAudioItem)
@ -608,10 +609,10 @@ void LLPanelNearByMedia::refreshParcelItems()
// ... then update it
if (NULL != mParcelAudioItem)
{
bool is_playing = LLViewerMedia::isParcelAudioPlaying();
bool is_playing = media_inst->isParcelAudioPlaying();
std::string url;
url = LLViewerMedia::getParcelAudioURL();
url = media_inst->getParcelAudioURL();
updateListItem(mParcelAudioItem,
mParcelAudioName,
@ -653,7 +654,8 @@ void LLPanelNearByMedia::refreshList()
refreshParcelItems();
// Get the canonical list from LLViewerMedia
LLViewerMedia::impl_list impls = LLViewerMedia::getPriorityList();
LLViewerMedia* media_inst = LLViewerMedia::getInstance();
LLViewerMedia::impl_list impls = media_inst->getPriorityList();
LLViewerMedia::impl_list::iterator priority_iter;
U32 enabled_count = 0;
@ -706,17 +708,17 @@ void LLPanelNearByMedia::refreshList()
}
mDisableAllCtrl->setEnabled((gSavedSettings.getBOOL("AudioStreamingMusic") ||
gSavedSettings.getBOOL("AudioStreamingMedia")) &&
(LLViewerMedia::isAnyMediaShowing() ||
LLViewerMedia::isParcelMediaPlaying() ||
LLViewerMedia::isParcelAudioPlaying()));
(media_inst->isAnyMediaShowing() ||
media_inst->isParcelMediaPlaying() ||
media_inst->isParcelAudioPlaying()));
mEnableAllCtrl->setEnabled( (gSavedSettings.getBOOL("AudioStreamingMusic") ||
gSavedSettings.getBOOL("AudioStreamingMedia")) &&
(disabled_count > 0 ||
// parcel media (if we have it, and it isn't playing, enable "start")
(LLViewerMedia::hasParcelMedia() && ! LLViewerMedia::isParcelMediaPlaying()) ||
(media_inst->hasParcelMedia() && ! media_inst->isParcelMediaPlaying()) ||
// parcel audio (if we have it, and it isn't playing, enable "start")
(LLViewerMedia::hasParcelAudio() && ! LLViewerMedia::isParcelAudioPlaying())));
(media_inst->hasParcelAudio() && ! media_inst->isParcelAudioPlaying())));
// Iterate over the rows in the control, updating ones whose impl exists, and deleting ones whose impl has gone away.
std::vector<LLScrollListItem*> items = mMediaList->getAllData();
@ -731,7 +733,7 @@ void LLPanelNearByMedia::refreshList()
if (row_id != PARCEL_MEDIA_LIST_ITEM_UUID &&
row_id != PARCEL_AUDIO_LIST_ITEM_UUID)
{
LLViewerMediaImpl* impl = LLViewerMedia::getMediaImplFromTextureID(row_id);
LLViewerMediaImpl* impl = media_inst->getMediaImplFromTextureID(row_id);
if(impl)
{
updateListItem(item, impl);
@ -776,17 +778,17 @@ void LLPanelNearByMedia::updateColumns()
void LLPanelNearByMedia::onClickEnableAll()
{
LLViewerMedia::setAllMediaEnabled(true);
LLViewerMedia::getInstance()->setAllMediaEnabled(true);
}
void LLPanelNearByMedia::onClickDisableAll()
{
LLViewerMedia::setAllMediaEnabled(false);
LLViewerMedia::getInstance()->setAllMediaEnabled(false);
}
void LLPanelNearByMedia::onClickEnableParcelMedia()
{
if ( ! LLViewerMedia::isParcelMediaPlaying() )
if ( ! LLViewerMedia::getInstance()->isParcelMediaPlaying() )
{
LLViewerParcelMedia::play(LLViewerParcelMgr::getInstance()->getAgentParcel());
}
@ -832,7 +834,7 @@ bool LLPanelNearByMedia::setDisabled(const LLUUID &row_id, bool disabled)
return true;
}
else {
LLViewerMediaImpl* impl = LLViewerMedia::getMediaImplFromTextureID(row_id);
LLViewerMediaImpl* impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(row_id);
if(impl)
{
impl->setDisabled(disabled, true);
@ -889,7 +891,7 @@ void LLPanelNearByMedia::onClickParcelAudioPlay()
}
else
{
LLViewerAudio::getInstance()->startInternetStreamWithAutoFade(LLViewerMedia::getParcelAudioURL());
LLViewerAudio::getInstance()->startInternetStreamWithAutoFade(LLViewerMedia::getInstance()->getParcelAudioURL());
}
}
@ -981,16 +983,17 @@ void LLPanelNearByMedia::onMoreLess()
void LLPanelNearByMedia::updateControls()
{
LLUUID selected_media_id = mMediaList->getValue().asUUID();
LLViewerMedia* media_inst = LLViewerMedia::getInstance();
if (selected_media_id == PARCEL_AUDIO_LIST_ITEM_UUID)
{
if (!LLViewerMedia::hasParcelAudio() || !gSavedSettings.getBOOL("AudioStreamingMusic"))
if (!media_inst->getInstance()->hasParcelAudio() || !gSavedSettings.getBOOL("AudioStreamingMusic"))
{
// disable controls if audio streaming music is disabled from preference
showDisabledControls();
}
else {
showTimeBasedControls(LLViewerMedia::isParcelAudioPlaying(),
showTimeBasedControls(media_inst->isParcelAudioPlaying(),
false, // include_zoom
false, // is_zoomed
gSavedSettings.getBOOL("MuteMusic"),
@ -999,7 +1002,7 @@ void LLPanelNearByMedia::updateControls()
}
else if (selected_media_id == PARCEL_MEDIA_LIST_ITEM_UUID)
{
if (!LLViewerMedia::hasParcelMedia() || !gSavedSettings.getBOOL("AudioStreamingMedia"))
if (!media_inst->hasParcelMedia() || !gSavedSettings.getBOOL("AudioStreamingMedia"))
{
// disable controls if audio streaming media is disabled from preference
showDisabledControls();
@ -1021,7 +1024,7 @@ void LLPanelNearByMedia::updateControls()
}
else {
// non-time-based parcel media
showBasicControls(LLViewerMedia::isParcelMediaPlaying(),
showBasicControls(media_inst->isParcelMediaPlaying(),
false,
false,
impl->getVolume() == 0.0,
@ -1030,7 +1033,7 @@ void LLPanelNearByMedia::updateControls()
}
}
else {
LLViewerMediaImpl* impl = LLViewerMedia::getMediaImplFromTextureID(selected_media_id);
LLViewerMediaImpl* impl = media_inst->getMediaImplFromTextureID(selected_media_id);
if (NULL == impl || !gSavedSettings.getBOOL("AudioStreamingMedia"))
{
@ -1116,7 +1119,7 @@ void LLPanelNearByMedia::onClickSelectedMediaPlay()
if (selected_media_id != PARCEL_AUDIO_LIST_ITEM_UUID)
{
LLViewerMediaImpl *impl = (selected_media_id == PARCEL_MEDIA_LIST_ITEM_UUID) ?
((LLViewerMediaImpl*)LLViewerParcelMedia::getParcelMedia()) : LLViewerMedia::getMediaImplFromTextureID(selected_media_id);
((LLViewerMediaImpl*)LLViewerParcelMedia::getParcelMedia()) : LLViewerMedia::getInstance()->getMediaImplFromTextureID(selected_media_id);
if (NULL != impl)
{
if (impl->isMediaTimeBased() && impl->isMediaPaused())
@ -1145,7 +1148,7 @@ void LLPanelNearByMedia::onClickSelectedMediaPause()
onClickParcelMediaPause();
}
else {
LLViewerMediaImpl* impl = LLViewerMedia::getMediaImplFromTextureID(selected_media_id);
LLViewerMediaImpl* impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(selected_media_id);
if (NULL != impl && impl->isMediaTimeBased() && impl->isMediaPlaying())
{
impl->pause();
@ -1162,7 +1165,7 @@ void LLPanelNearByMedia::onClickSelectedMediaMute()
}
else {
LLViewerMediaImpl* impl = (selected_media_id == PARCEL_MEDIA_LIST_ITEM_UUID) ?
((LLViewerMediaImpl*)LLViewerParcelMedia::getParcelMedia()) : LLViewerMedia::getMediaImplFromTextureID(selected_media_id);
((LLViewerMediaImpl*)LLViewerParcelMedia::getParcelMedia()) : LLViewerMedia::getInstance()->getMediaImplFromTextureID(selected_media_id);
if (NULL != impl)
{
F32 volume = impl->getVolume();
@ -1193,7 +1196,7 @@ void LLPanelNearByMedia::onCommitSelectedMediaVolume()
}
else {
LLViewerMediaImpl* impl = (selected_media_id == PARCEL_MEDIA_LIST_ITEM_UUID) ?
((LLViewerMediaImpl*)LLViewerParcelMedia::getParcelMedia()) : LLViewerMedia::getMediaImplFromTextureID(selected_media_id);
((LLViewerMediaImpl*)LLViewerParcelMedia::getParcelMedia()) : LLViewerMedia::getInstance()->getMediaImplFromTextureID(selected_media_id);
if (NULL != impl)
{
impl->setVolume(mVolumeSlider->getValueF32());

2
indra/newview/llpanelprimmediacontrols.cpp
View File

@ -267,7 +267,7 @@ void LLPanelPrimMediaControls::focusOnTarget()
LLViewerMediaImpl* LLPanelPrimMediaControls::getTargetMediaImpl()
{
return LLViewerMedia::getMediaImplFromTextureID(mTargetImplID);
return LLViewerMedia::getInstance()->getMediaImplFromTextureID(mTargetImplID);
}
LLViewerObject* LLPanelPrimMediaControls::getTargetObject()

4
indra/newview/llprogressview.cpp
View File

@ -86,7 +86,7 @@ BOOL LLProgressView::postBuild()
mMediaCtrl->setVisible( false ); // hidden initially
mMediaCtrl->addObserver( this ); // watch events
LLViewerMedia::setOnlyAudibleMediaTextureID(mMediaCtrl->getTextureID());
LLViewerMedia::getInstance()->setOnlyAudibleMediaTextureID(mMediaCtrl->getTextureID());
mCancelBtn = getChild<LLButton>("cancel_btn");
mCancelBtn->setClickedCallback( LLProgressView::onCancelButtonClicked, NULL );
@ -263,7 +263,7 @@ void LLProgressView::draw()
{
mFadeToWorldTimer.stop();
LLViewerMedia::setOnlyAudibleMediaTextureID(LLUUID::null);
LLViewerMedia::getInstance()->setOnlyAudibleMediaTextureID(LLUUID::null);
// Fade is complete, release focus
gFocusMgr.releaseFocusIfNeeded( this );

2
indra/newview/llstartup.cpp
View File

@ -3543,7 +3543,7 @@ bool process_login_success_response()
if(!openid_url.empty())
{
std::string openid_token = response["openid_token"];
LLViewerMedia::openIDSetup(openid_url, openid_token);
LLViewerMedia::getInstance()->openIDSetup(openid_url, openid_token);
}
gMaxAgentGroups = DEFAULT_MAX_AGENT_GROUPS;

14
indra/newview/llstatusbar.cpp
View File

@ -310,16 +310,18 @@ void LLStatusBar::refresh()
// update the master volume button state
bool mute_audio = LLAppViewer::instance()->getMasterSystemAudioMute();
mBtnVolume->setToggleState(mute_audio);
LLViewerMedia* media_inst = LLViewerMedia::getInstance();
// Disable media toggle if there's no media, parcel media, and no parcel audio
// (or if media is disabled)
bool button_enabled = (gSavedSettings.getBOOL("AudioStreamingMusic")||gSavedSettings.getBOOL("AudioStreamingMedia")) &&
(LLViewerMedia::hasInWorldMedia() || LLViewerMedia::hasParcelMedia() || LLViewerMedia::hasParcelAudio());
(media_inst->hasInWorldMedia() || media_inst->hasParcelMedia() || media_inst->hasParcelAudio());
mMediaToggle->setEnabled(button_enabled);
// Note the "sense" of the toggle is opposite whether media is playing or not
bool any_media_playing = (LLViewerMedia::isAnyMediaPlaying() ||
LLViewerMedia::isParcelMediaPlaying() ||
LLViewerMedia::isParcelAudioPlaying());
bool any_media_playing = (media_inst->isAnyMediaPlaying() ||
media_inst->isParcelMediaPlaying() ||
media_inst->isParcelAudioPlaying());
mMediaToggle->setValue(!any_media_playing);
}
@ -578,7 +580,7 @@ void LLStatusBar::onClickMediaToggle(void* data)
LLStatusBar *status_bar = (LLStatusBar*)data;
// "Selected" means it was showing the "play" icon (so media was playing), and now it shows "pause", so turn off media
bool pause = status_bar->mMediaToggle->getValue();
LLViewerMedia::setAllMediaPaused(pause);
LLViewerMedia::getInstance()->setAllMediaPaused(pause);
}
BOOL can_afford_transaction(S32 cost)

16
indra/newview/lltoolpie.cpp
View File

@ -1130,7 +1130,7 @@ BOOL LLToolPie::handleTooltipObject( LLViewerObject* hover_object, std::string l
const LLMediaEntry* mep = has_media ? tep->getMediaData() : NULL;
if (mep)
{
viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
viewer_media_t media_impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mep->getMediaID());
LLPluginClassMedia* media_plugin = NULL;
if (media_impl.notNull() && (media_impl->hasMedia()))
@ -1305,7 +1305,7 @@ void LLToolPie::playCurrentMedia(const LLPickInfo& info)
LLPluginClassMedia* media_plugin = NULL;
viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
viewer_media_t media_impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mep->getMediaID());
if(media_impl.notNull() && media_impl->hasMedia())
{
@ -1357,7 +1357,7 @@ void LLToolPie::VisitHomePage(const LLPickInfo& info)
LLPluginClassMedia* media_plugin = NULL;
viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
viewer_media_t media_impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mep->getMediaID());
if(media_impl.notNull() && media_impl->hasMedia())
{
@ -1500,7 +1500,7 @@ bool LLToolPie::handleMediaClick(const LLPickInfo& pick)
if (!mep)
return false;
viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
viewer_media_t media_impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mep->getMediaID());
if (gSavedSettings.getBOOL("MediaOnAPrimUI"))
{
@ -1554,7 +1554,7 @@ bool LLToolPie::handleMediaDblClick(const LLPickInfo& pick)
if (!mep)
return false;
viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
viewer_media_t media_impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mep->getMediaID());
if (gSavedSettings.getBOOL("MediaOnAPrimUI"))
{
@ -1609,7 +1609,7 @@ bool LLToolPie::handleMediaHover(const LLPickInfo& pick)
if (mep
&& gSavedSettings.getBOOL("MediaOnAPrimUI"))
{
viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
viewer_media_t media_impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mep->getMediaID());
if(media_impl.notNull())
{
@ -1647,7 +1647,7 @@ bool LLToolPie::handleMediaMouseUp()
if(mMediaMouseCaptureID.notNull())
{
// Face media needs to know the mouse went up.
viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mMediaMouseCaptureID);
viewer_media_t media_impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mMediaMouseCaptureID);
if(media_impl)
{
// This will send a mouseUp event to the plugin using the last known mouse coordinate (from a mouseDown or mouseMove), which is what we want.
@ -1676,7 +1676,7 @@ static void handle_click_action_open_media(LLPointer<LLViewerObject> objectp)
if( face < 0 || face >= objectp->getNumTEs() ) return;
// is media playing on this face?
if (LLViewerMedia::getMediaImplFromTextureID(objectp->getTE(face)->getID()) != NULL)
if (LLViewerMedia::getInstance()->getMediaImplFromTextureID(objectp->getTE(face)->getID()) != NULL)
{
handle_click_action_play();
return;

2
indra/newview/llvieweraudio.cpp
View File

@ -463,7 +463,7 @@ void audio_update_volume(bool force_update)
F32 media_volume = gSavedSettings.getF32("AudioLevelMedia");
BOOL media_muted = gSavedSettings.getBOOL("MuteMedia");
media_volume = mute_volume * master_volume * media_volume;
LLViewerMedia::setVolume( media_muted ? 0.0f : media_volume );
LLViewerMedia::getInstance()->setVolume( media_muted ? 0.0f : media_volume );
// Voice
if (LLVoiceClient::getInstance())

187
indra/newview/llviewermedia.cpp
View File

@ -77,12 +77,6 @@
#include <boost/bind.hpp> // for SkinFolder listener
#include <boost/signals2.hpp>
/*static*/ const char* LLViewerMedia::AUTO_PLAY_MEDIA_SETTING = "ParcelMediaAutoPlayEnable";
/*static*/ const char* LLViewerMedia::SHOW_MEDIA_ON_OTHERS_SETTING = "MediaShowOnOthers";
/*static*/ const char* LLViewerMedia::SHOW_MEDIA_WITHIN_PARCEL_SETTING = "MediaShowWithinParcel";
/*static*/ const char* LLViewerMedia::SHOW_MEDIA_OUTSIDE_PARCEL_SETTING = "MediaShowOutsideParcel";
class LLMediaFilePicker : public LLFilePickerThread // deletes itself when done
{
public:
@ -191,9 +185,6 @@ LLViewerMediaObserver::~LLViewerMediaObserver()
}
LLURL LLViewerMedia::sOpenIDURL;
std::string LLViewerMedia::sOpenIDCookie;
LLPluginClassMedia* LLViewerMedia::sSpareBrowserMediaSource = NULL;
static LLViewerMedia::impl_list sViewerMediaImplList;
static LLViewerMedia::impl_id_map sViewerMediaTextureIDMap;
static LLTimer sMediaCreateTimer;
@ -203,8 +194,6 @@ static bool sForceUpdate = false;
static LLUUID sOnlyAudibleTextureID = LLUUID::null;
static F64 sLowestLoadableImplInterest = 0.0f;
static bool sAnyMediaShowing = false;
static bool sAnyMediaPlaying = false;
static boost::signals2::connection sTeleportFinishConnection;
//////////////////////////////////////////////////////////////////////////////////////////
static void add_media_impl(LLViewerMediaImpl* media)
@ -230,7 +219,7 @@ static void remove_media_impl(LLViewerMediaImpl* media)
class LLViewerMediaMuteListObserver : public LLMuteListObserver
{
/* virtual */ void onChange() { LLViewerMedia::muteListChanged();}
/* virtual */ void onChange() { LLViewerMedia::getInstance()->muteListChanged();}
};
static LLViewerMediaMuteListObserver sViewerMediaMuteListObserver;
@ -239,9 +228,40 @@ static bool sViewerMediaMuteListObserverInitialized = false;
//////////////////////////////////////////////////////////////////////////////////////////
// LLViewerMedia
//////////////////////////////////////////////////////////////////////////////////////////
/*static*/ const char* LLViewerMedia::AUTO_PLAY_MEDIA_SETTING = "ParcelMediaAutoPlayEnable";
/*static*/ const char* LLViewerMedia::SHOW_MEDIA_ON_OTHERS_SETTING = "MediaShowOnOthers";
/*static*/ const char* LLViewerMedia::SHOW_MEDIA_WITHIN_PARCEL_SETTING = "MediaShowWithinParcel";
/*static*/ const char* LLViewerMedia::SHOW_MEDIA_OUTSIDE_PARCEL_SETTING = "MediaShowOutsideParcel";
LLViewerMedia::LLViewerMedia():
mAnyMediaShowing(false),
mAnyMediaPlaying(false),
mSpareBrowserMediaSource(NULL)
{
}
LLViewerMedia::~LLViewerMedia()
{
gIdleCallbacks.deleteFunction(LLViewerMedia::onIdle, NULL);
mTeleportFinishConnection.disconnect();
if (mSpareBrowserMediaSource != NULL)
{
delete mSpareBrowserMediaSource;
mSpareBrowserMediaSource = NULL;
}
}
// static
void LLViewerMedia::initSingleton()
{
gIdleCallbacks.addFunction(LLViewerMedia::onIdle, NULL);
mTeleportFinishConnection = LLViewerParcelMgr::getInstance()->
setTeleportFinishedCallback(boost::bind(&LLViewerMedia::onTeleportFinished, this));
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
viewer_media_t LLViewerMedia::newMediaImpl(
const LLUUID& texture_id,
S32 media_width,
@ -368,7 +388,6 @@ viewer_media_t LLViewerMedia::updateMediaImpl(LLMediaEntry* media_entry, const s
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
LLViewerMediaImpl* LLViewerMedia::getMediaImplFromTextureID(const LLUUID& texture_id)
{
LLViewerMediaImpl* result = NULL;
@ -384,7 +403,6 @@ LLViewerMediaImpl* LLViewerMedia::getMediaImplFromTextureID(const LLUUID& textur
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
std::string LLViewerMedia::getCurrentUserAgent()
{
// Don't use user-visible string to avoid
@ -411,7 +429,6 @@ std::string LLViewerMedia::getCurrentUserAgent()
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::updateBrowserUserAgent()
{
std::string user_agent = getCurrentUserAgent();
@ -431,7 +448,6 @@ void LLViewerMedia::updateBrowserUserAgent()
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
bool LLViewerMedia::handleSkinCurrentChanged(const LLSD& /*newvalue*/)
{
// gSavedSettings is already updated when this function is called.
@ -440,7 +456,6 @@ bool LLViewerMedia::handleSkinCurrentChanged(const LLSD& /*newvalue*/)
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
bool LLViewerMedia::textureHasMedia(const LLUUID& texture_id)
{
impl_list::iterator iter = sViewerMediaImplList.begin();
@ -458,7 +473,6 @@ bool LLViewerMedia::textureHasMedia(const LLUUID& texture_id)
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::setVolume(F32 volume)
{
if(volume != sGlobalVolume || sForceUpdate)
@ -478,14 +492,12 @@ void LLViewerMedia::setVolume(F32 volume)
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
F32 LLViewerMedia::getVolume()
{
return sGlobalVolume;
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::muteListChanged()
{
// When the mute list changes, we need to check mute status on all impls.
@ -500,7 +512,6 @@ void LLViewerMedia::muteListChanged()
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
bool LLViewerMedia::isInterestingEnough(const LLVOVolume *object, const F64 &object_interest)
{
bool result = false;
@ -535,6 +546,7 @@ LLViewerMedia::impl_list &LLViewerMedia::getPriorityList()
return sViewerMediaImplList;
}
// static
// This is the predicate function used to sort sViewerMediaImplList by priority.
bool LLViewerMedia::priorityComparitor(const LLViewerMediaImpl* i1, const LLViewerMediaImpl* i2)
{
@ -629,7 +641,12 @@ static LLTrace::BlockTimerStatHandle FTM_MEDIA_MISC("Misc");
//////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::onIdle(void *dummy_arg)
{
LLViewerMedia::getInstance()->updateMedia(dummy_arg);
}
//////////////////////////////////////////////////////////////////////////////////////////
void LLViewerMedia::updateMedia(void *dummy_arg)
{
LL_RECORD_BLOCK_TIME(FTM_MEDIA_UPDATE);
@ -642,8 +659,8 @@ void LLViewerMedia::updateMedia(void *dummy_arg)
// removing it for now.
//createSpareBrowserMediaSource();
sAnyMediaShowing = false;
sAnyMediaPlaying = false;
mAnyMediaShowing = false;
mAnyMediaPlaying = false;
impl_list::iterator iter = sViewerMediaImplList.begin();
impl_list::iterator end = sViewerMediaImplList.end();
@ -659,10 +676,10 @@ void LLViewerMedia::updateMedia(void *dummy_arg)
}
// Let the spare media source actually launch
if(sSpareBrowserMediaSource)
if(mSpareBrowserMediaSource)
{
LL_RECORD_BLOCK_TIME(FTM_MEDIA_SPARE_IDLE);
sSpareBrowserMediaSource->idle();
mSpareBrowserMediaSource->idle();
}
{
@ -854,7 +871,7 @@ void LLViewerMedia::updateMedia(void *dummy_arg)
if (!pimpl->getUsedInUI() && pimpl->hasMedia() && (pimpl->isMediaPlaying() || !pimpl->isMediaTimeBased()))
{
// consider visible non-timebased media as playing
sAnyMediaPlaying = true;
mAnyMediaPlaying = true;
}
}
@ -899,21 +916,18 @@ void LLViewerMedia::updateMedia(void *dummy_arg)
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
bool LLViewerMedia::isAnyMediaShowing()
{
return sAnyMediaShowing;
return mAnyMediaShowing;
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
bool LLViewerMedia::isAnyMediaPlaying()
{
return sAnyMediaPlaying;
return mAnyMediaPlaying;
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::setAllMediaEnabled(bool val)
{
// Set "tentative" autoplay first. We need to do this here or else
@ -969,7 +983,6 @@ void LLViewerMedia::setAllMediaEnabled(bool val)
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::setAllMediaPaused(bool val)
{
// Set "tentative" autoplay first. We need to do this here or else
@ -1041,19 +1054,24 @@ void LLViewerMedia::setAllMediaPaused(bool val)
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
bool LLViewerMedia::isParcelMediaPlaying()
{
return (LLViewerMedia::hasParcelMedia() && LLViewerParcelMedia::getParcelMedia() && LLViewerParcelMedia::getParcelMedia()->hasMedia());
}
/////////////////////////////////////////////////////////////////////////////////////////
// static
bool LLViewerMedia::isParcelAudioPlaying()
{
return (LLViewerMedia::hasParcelAudio() && gAudiop && LLAudioEngine::AUDIO_PLAYING == gAudiop->isInternetStreamPlaying());
}
/////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::authSubmitCallback(const LLSD& notification, const LLSD& response)
{
LLViewerMedia::getInstance()->onAuthSubmit(notification, response);
}
void LLViewerMedia::onAuthSubmit(const LLSD& notification, const LLSD& response)
{
LLViewerMediaImpl *impl = LLViewerMedia::getMediaImplFromTextureID(notification["payload"]["media_id"]);
@ -1075,7 +1093,6 @@ void LLViewerMedia::onAuthSubmit(const LLSD& notification, const LLSD& response)
}
/////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::clearAllCookies()
{
// Clear all cookies for all plugins
@ -1092,7 +1109,6 @@ void LLViewerMedia::clearAllCookies()
}
/////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::clearAllCaches()
{
// Clear all plugins' caches
@ -1106,7 +1122,6 @@ void LLViewerMedia::clearAllCaches()
}
/////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::setCookiesEnabled(bool enabled)
{
// Set the "cookies enabled" flag for all loaded plugins
@ -1123,7 +1138,6 @@ void LLViewerMedia::setCookiesEnabled(bool enabled)
}
/////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::setProxyConfig(bool enable, const std::string &host, int port)
{
// Set the proxy config for all loaded plugins
@ -1140,10 +1154,6 @@ void LLViewerMedia::setProxyConfig(bool enable, const std::string &host, int por
}
/////////////////////////////////////////////////////////////////////////////////////////
// static
/////////////////////////////////////////////////////////////////////////////////////////
//// static
LLSD LLViewerMedia::getHeaders()
{
LLSD headers = LLSD::emptyMap();
@ -1151,14 +1161,13 @@ LLSD LLViewerMedia::getHeaders()
// *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] = sOpenIDCookie;
headers[HTTP_OUT_HEADER_COOKIE] = mOpenIDCookie;
headers[HTTP_OUT_HEADER_USER_AGENT] = getCurrentUserAgent();
return headers;
}
/////////////////////////////////////////////////////////////////////////////////////////
// static
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("=");
@ -1181,13 +1190,14 @@ bool LLViewerMedia::parseRawCookie(const std::string raw_cookie, std::string& na
return false;
}
/////////////////////////////////////////////////////////////////////////////////////////
LLCore::HttpHeaders::ptr_t LLViewerMedia::getHttpHeaders()
{
LLCore::HttpHeaders::ptr_t headers(new LLCore::HttpHeaders);
headers->append(HTTP_OUT_HEADER_ACCEPT, "*/*");
headers->append(HTTP_OUT_HEADER_CONTENT_TYPE, HTTP_CONTENT_XML);
headers->append(HTTP_OUT_HEADER_COOKIE, sOpenIDCookie);
headers->append(HTTP_OUT_HEADER_COOKIE, mOpenIDCookie);
headers->append(HTTP_OUT_HEADER_USER_AGENT, getCurrentUserAgent());
return headers;
@ -1195,10 +1205,9 @@ LLCore::HttpHeaders::ptr_t LLViewerMedia::getHttpHeaders()
/////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::setOpenIDCookie(const std::string& url)
{
if(!sOpenIDCookie.empty())
if(!mOpenIDCookie.empty())
{
std::string profileUrl = getProfileURL("");
@ -1207,7 +1216,7 @@ void LLViewerMedia::setOpenIDCookie(const std::string& url)
}
}
/*static*/
//static
void LLViewerMedia::getOpenIDCookieCoro(std::string url)
{
LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
@ -1229,7 +1238,7 @@ void LLViewerMedia::getOpenIDCookieCoro(std::string url)
// The LLURL can give me the 'authority', which is of the form: [username[:password]@]hostname[:port]
// We want just the hostname for the cookie code, but LLURL doesn't seem to have a way to extract that.
// We therefore do it here.
std::string authority = sOpenIDURL.mAuthority;
std::string authority = getInstance()->mOpenIDURL.mAuthority;
std::string::size_type hostStart = authority.find('@');
if (hostStart == std::string::npos)
{ // no username/password
@ -1246,7 +1255,8 @@ 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");
@ -1258,8 +1268,8 @@ void LLViewerMedia::getOpenIDCookieCoro(std::string url)
std::string cookie_path = "";
bool httponly = true;
bool secure = true;
if (parseRawCookie(sOpenIDCookie, cookie_name, cookie_value, cookie_path, httponly, secure) &&
media_instance->getMediaPlugin())
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.
@ -1268,7 +1278,7 @@ void LLViewerMedia::getOpenIDCookieCoro(std::string url)
// (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(sOpenIDURL.mURI) + "://" + std::string(sOpenIDURL.mAuthority));
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);
}
@ -1281,11 +1291,11 @@ void LLViewerMedia::getOpenIDCookieCoro(std::string url)
// Do a web profile get so we can store the cookie
httpHeaders->append(HTTP_OUT_HEADER_ACCEPT, "*/*");
httpHeaders->append(HTTP_OUT_HEADER_COOKIE, sOpenIDCookie);
httpHeaders->append(HTTP_OUT_HEADER_USER_AGENT, getCurrentUserAgent());
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 = [" << sOpenIDCookie << "]" << LL_ENDL;
LL_DEBUGS("MediaAuth") << "sOpenIDCookie = [" << inst->mOpenIDCookie << "]" << LL_ENDL;
LLSD result = httpAdapter->getRawAndSuspend(httpRequest, url, httpOpts, httpHeaders);
@ -1314,7 +1324,6 @@ void LLViewerMedia::getOpenIDCookieCoro(std::string url)
}
/////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::openIDSetup(const std::string &openidUrl, const std::string &openidToken)
{
LL_DEBUGS("MediaAuth") << "url = \"" << openidUrl << "\", token = \"" << openidToken << "\"" << LL_ENDL;
@ -1323,7 +1332,6 @@ void LLViewerMedia::openIDSetup(const std::string &openidUrl, const std::string
boost::bind(&LLViewerMedia::openIDSetupCoro, openidUrl, openidToken));
}
/*static*/
void LLViewerMedia::openIDSetupCoro(std::string openidUrl, std::string openidToken)
{
LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
@ -1338,10 +1346,10 @@ void LLViewerMedia::openIDSetupCoro(std::string openidUrl, std::string openidTok
// 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.
sOpenIDURL.init(openidUrl.c_str());
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.
sOpenIDCookie.clear();
getInstance()->mOpenIDCookie.clear();
httpHeaders->append(HTTP_OUT_HEADER_ACCEPT, "*/*");
httpHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, "application/x-www-form-urlencoded");
@ -1373,24 +1381,22 @@ void LLViewerMedia::openIDSetupCoro(std::string openidUrl, std::string openidTok
const std::string& cookie = resultHeaders[HTTP_IN_HEADER_SET_COOKIE].asString();
// *TODO: What about bad status codes? Does this destroy previous cookies?
LLViewerMedia::openIDCookieResponse(openidUrl, cookie);
LLViewerMedia::getInstance()->openIDCookieResponse(openidUrl, cookie);
LL_DEBUGS("MediaAuth") << "OpenID cookie set." << LL_ENDL;
}
/////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::openIDCookieResponse(const std::string& url, const std::string &cookie)
{
LL_DEBUGS("MediaAuth") << "Cookie received: \"" << cookie << "\"" << LL_ENDL;
sOpenIDCookie += cookie;
mOpenIDCookie += cookie;
setOpenIDCookie(url);
}
/////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::proxyWindowOpened(const std::string &target, const std::string &uuid)
{
if(uuid.empty())
@ -1406,7 +1412,6 @@ void LLViewerMedia::proxyWindowOpened(const std::string &target, const std::stri
}
/////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::proxyWindowClosed(const std::string &uuid)
{
if(uuid.empty())
@ -1422,28 +1427,26 @@ void LLViewerMedia::proxyWindowClosed(const std::string &uuid)
}
/////////////////////////////////////////////////////////////////////////////////////////
// static
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 (!sSpareBrowserMediaSource && !gSavedSettings.getBOOL("PluginAttachDebuggerToPlugins"))
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)
sSpareBrowserMediaSource = LLViewerMediaImpl::newSourceFromMediaType(HTTP_CONTENT_TEXT_HTML, NULL, 0, 0, 1.0);
mSpareBrowserMediaSource = LLViewerMediaImpl::newSourceFromMediaType(HTTP_CONTENT_TEXT_HTML, NULL, 0, 0, 1.0);
}
}
/////////////////////////////////////////////////////////////////////////////////////////
// static
LLPluginClassMedia* LLViewerMedia::getSpareBrowserMediaSource()
{
LLPluginClassMedia* result = sSpareBrowserMediaSource;
sSpareBrowserMediaSource = NULL;
LLPluginClassMedia* result = mSpareBrowserMediaSource;
mSpareBrowserMediaSource = NULL;
return result;
};
@ -1465,50 +1468,24 @@ bool LLViewerMedia::hasInWorldMedia()
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
bool LLViewerMedia::hasParcelMedia()
{
return !LLViewerParcelMedia::getURL().empty();
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
bool LLViewerMedia::hasParcelAudio()
{
return !LLViewerMedia::getParcelAudioURL().empty();
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
std::string LLViewerMedia::getParcelAudioURL()
{
return LLViewerParcelMgr::getInstance()->getAgentParcel()->getMusicURL();
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::initClass()
{
gIdleCallbacks.addFunction(LLViewerMedia::updateMedia, NULL);
sTeleportFinishConnection = LLViewerParcelMgr::getInstance()->
setTeleportFinishedCallback(boost::bind(&LLViewerMedia::onTeleportFinished));
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::cleanupClass()
{
gIdleCallbacks.deleteFunction(LLViewerMedia::updateMedia, NULL);
sTeleportFinishConnection.disconnect();
if (sSpareBrowserMediaSource != NULL)
{
delete sSpareBrowserMediaSource;
sSpareBrowserMediaSource = NULL;
}
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::onTeleportFinished()
{
// On teleport, clear this setting (i.e. set it to true)
@ -1517,9 +1494,7 @@ void LLViewerMedia::onTeleportFinished()
LLViewerMediaImpl::sMimeTypesFailed.clear();
}
//////////////////////////////////////////////////////////////////////////////////////////
// static
void LLViewerMedia::setOnlyAudibleMediaTextureID(const LLUUID& texture_id)
{
sOnlyAudibleTextureID = texture_id;
@ -1711,7 +1686,7 @@ LLPluginClassMedia* LLViewerMediaImpl::newSourceFromMediaType(std::string media_
if ((plugin_basename == "media_plugin_cef") &&
!gSavedSettings.getBOOL("PluginAttachDebuggerToPlugins") && !clean_browser)
{
media_source = LLViewerMedia::getSpareBrowserMediaSource();
media_source = LLViewerMedia::getInstance()->getSpareBrowserMediaSource();
if(media_source)
{
media_source->setOwner(owner);
@ -1787,7 +1762,7 @@ LLPluginClassMedia* LLViewerMediaImpl::newSourceFromMediaType(std::string media_
media_source->enableMediaPluginDebugging( media_plugin_debugging_enabled || clean_browser);
// need to set agent string here before instance created
media_source->setBrowserUserAgent(LLViewerMedia::getCurrentUserAgent());
media_source->setBrowserUserAgent(LLViewerMedia::getInstance()->getCurrentUserAgent());
media_source->setTarget(target);
@ -1858,7 +1833,7 @@ bool LLViewerMediaImpl::initializePlugin(const std::string& media_type)
media_source->setDisableTimeout(gSavedSettings.getBOOL("DebugPluginDisableTimeout"));
media_source->setLoop(mMediaLoop);
media_source->setAutoScale(mMediaAutoScale);
media_source->setBrowserUserAgent(LLViewerMedia::getCurrentUserAgent());
media_source->setBrowserUserAgent(LLViewerMedia::getInstance()->getCurrentUserAgent());
media_source->focus(mHasFocus);
media_source->setBackgroundColor(mBackgroundColor);
@ -2104,7 +2079,7 @@ void LLViewerMediaImpl::updateVolume()
if(mMediaSource)
{
// always scale the volume by the global media volume
F32 volume = mRequestedVolume * LLViewerMedia::getVolume();
F32 volume = mRequestedVolume * LLViewerMedia::getInstance()->getVolume();
if (mProximityCamera > 0)
{
@ -3378,7 +3353,7 @@ void LLViewerMediaImpl::handleMediaEvent(LLPluginClassMedia* plugin, LLPluginCla
auth_request_params.substitutions = args;
auth_request_params.payload = LLSD().with("media_id", mTextureId);
auth_request_params.functor.function = boost::bind(&LLViewerMedia::onAuthSubmit, _1, _2);
auth_request_params.functor.function = boost::bind(&LLViewerMedia::authSubmitCallback, _1, _2);
LLNotifications::instance().add(auth_request_params);
};
break;

109
indra/newview/llviewermedia.h
View File

@ -70,11 +70,14 @@ private:
class LLViewerMediaImpl;
class LLViewerMedia
class LLViewerMedia: public LLSingleton<LLViewerMedia>
{
LLSINGLETON(LLViewerMedia);
~LLViewerMedia();
void initSingleton();
LOG_CLASS(LLViewerMedia);
public:
// String to get/set media autoplay in gSavedSettings
static const char* AUTO_PLAY_MEDIA_SETTING;
static const char* SHOW_MEDIA_ON_OTHERS_SETTING;
@ -88,91 +91,93 @@ public:
// Special case early init for just web browser component
// so we can show login screen. See .cpp file for details. JC
static viewer_media_t newMediaImpl(const LLUUID& texture_id,
viewer_media_t newMediaImpl(const LLUUID& texture_id,
S32 media_width = 0,
S32 media_height = 0,
U8 media_auto_scale = false,
U8 media_loop = false);
static viewer_media_t updateMediaImpl(LLMediaEntry* media_entry, const std::string& previous_url, bool update_from_self);
static LLViewerMediaImpl* getMediaImplFromTextureID(const LLUUID& texture_id);
static std::string getCurrentUserAgent();
static void updateBrowserUserAgent();
static bool handleSkinCurrentChanged(const LLSD& /*newvalue*/);
static bool textureHasMedia(const LLUUID& texture_id);
static void setVolume(F32 volume);
viewer_media_t updateMediaImpl(LLMediaEntry* media_entry, const std::string& previous_url, bool update_from_self);
LLViewerMediaImpl* getMediaImplFromTextureID(const LLUUID& texture_id);
std::string getCurrentUserAgent();
void updateBrowserUserAgent();
bool handleSkinCurrentChanged(const LLSD& /*newvalue*/);
bool textureHasMedia(const LLUUID& texture_id);
void setVolume(F32 volume);
// Is any media currently "showing"? Includes Parcel Media. Does not include media in the UI.
static bool isAnyMediaShowing();
bool isAnyMediaShowing();
// Shows if any media is playing, counts visible non time based media as playing. Does not include media in the UI.
static bool isAnyMediaPlaying();
bool isAnyMediaPlaying();
// Set all media enabled or disabled, depending on val. Does not include media in the UI.
static void setAllMediaEnabled(bool val);
void setAllMediaEnabled(bool val);
// Set all media paused(stopped for non time based) or playing, depending on val. Does not include media in the UI.
static void setAllMediaPaused(bool val);
void setAllMediaPaused(bool val);
static void updateMedia(void* dummy_arg = NULL);
static void initClass();
static void cleanupClass();
static F32 getVolume();
static void muteListChanged();
static bool isInterestingEnough(const LLVOVolume* object, const F64 &object_interest);
static void onIdle(void* dummy_arg = NULL); // updateMedia wrapper
void updateMedia(void* dummy_arg = NULL);
F32 getVolume();
void muteListChanged();
bool isInterestingEnough(const LLVOVolume* object, const F64 &object_interest);
// Returns the priority-sorted list of all media impls.
static impl_list &getPriorityList();
impl_list &getPriorityList();
// This is the comparitor used to sort the list.
static bool priorityComparitor(const LLViewerMediaImpl* i1, const LLViewerMediaImpl* i2);
// These are just helper functions for the convenience of others working with media
static bool hasInWorldMedia();
static std::string getParcelAudioURL();
static bool hasParcelMedia();
static bool hasParcelAudio();
static bool isParcelMediaPlaying();
static bool isParcelAudioPlaying();
static void onAuthSubmit(const LLSD& notification, const LLSD& response);
bool hasInWorldMedia();
std::string getParcelAudioURL();
bool hasParcelMedia();
bool hasParcelAudio();
bool isParcelMediaPlaying();
bool isParcelAudioPlaying();
static void authSubmitCallback(const LLSD& notification, const LLSD& response);
// Clear all cookies for all plugins
static void clearAllCookies();
void clearAllCookies();
// Clear all plugins' caches
static void clearAllCaches();
void clearAllCaches();
// Set the "cookies enabled" flag for all loaded plugins
static void setCookiesEnabled(bool enabled);
void setCookiesEnabled(bool enabled);
// Set the proxy config for all loaded plugins
static void setProxyConfig(bool enable, const std::string &host, int port);
void setProxyConfig(bool enable, const std::string &host, int port);
static void openIDSetup(const std::string &openid_url, const std::string &openid_token);
static void openIDCookieResponse(const std::string& url, const std::string &cookie);
void openIDSetup(const std::string &openid_url, const std::string &openid_token);
void openIDCookieResponse(const std::string& url, const std::string &cookie);
static void proxyWindowOpened(const std::string &target, const std::string &uuid);
static void proxyWindowClosed(const std::string &uuid);
void proxyWindowOpened(const std::string &target, const std::string &uuid);
void proxyWindowClosed(const std::string &uuid);
static void createSpareBrowserMediaSource();
static LLPluginClassMedia* getSpareBrowserMediaSource();
void createSpareBrowserMediaSource();
LLPluginClassMedia* getSpareBrowserMediaSource();
static void setOnlyAudibleMediaTextureID(const LLUUID& texture_id);
void setOnlyAudibleMediaTextureID(const LLUUID& texture_id);
static LLSD getHeaders();
static LLCore::HttpHeaders::ptr_t getHttpHeaders();
LLSD getHeaders();
LLCore::HttpHeaders::ptr_t getHttpHeaders();
private:
static bool parseRawCookie(const std::string raw_cookie, std::string& name, std::string& value, std::string& path, bool& httponly, bool& secure);
static void setOpenIDCookie(const std::string& url);
static void onTeleportFinished();
void onAuthSubmit(const LLSD& notification, const LLSD& response);
bool parseRawCookie(const std::string raw_cookie, std::string& name, std::string& value, std::string& path, bool& httponly, bool& secure);
void setOpenIDCookie(const std::string& url);
void onTeleportFinished();
static void openIDSetupCoro(std::string openidUrl, std::string openidToken);
static void getOpenIDCookieCoro(std::string url);
static void openIDSetupCoro(std::string openidUrl, std::string openidToken);
static void getOpenIDCookieCoro(std::string url);
static LLURL sOpenIDURL;
static std::string sOpenIDCookie;
static LLPluginClassMedia* sSpareBrowserMediaSource;
bool mAnyMediaShowing;
bool mAnyMediaPlaying;
LLURL mOpenIDURL;
std::string mOpenIDCookie;
LLPluginClassMedia* mSpareBrowserMediaSource;
boost::signals2::connection mTeleportFinishConnection;
};
// Implementation functions not exported into header file

6
indra/newview/llviewermediafocus.cpp
View File

@ -537,7 +537,7 @@ bool LLViewerMediaFocus::isHoveringOverFace(LLPointer<LLViewerObject> objectp, S
LLViewerMediaImpl* LLViewerMediaFocus::getFocusedMediaImpl()
{
return LLViewerMedia::getMediaImplFromTextureID(mFocusedImplID);
return LLViewerMedia::getInstance()->getMediaImplFromTextureID(mFocusedImplID);
}
LLViewerObject* LLViewerMediaFocus::getFocusedObject()
@ -547,7 +547,7 @@ LLViewerObject* LLViewerMediaFocus::getFocusedObject()
LLViewerMediaImpl* LLViewerMediaFocus::getHoverMediaImpl()
{
return LLViewerMedia::getMediaImplFromTextureID(mHoverImplID);
return LLViewerMedia::getInstance()->getMediaImplFromTextureID(mHoverImplID);
}
LLViewerObject* LLViewerMediaFocus::getHoverObject()
@ -557,7 +557,7 @@ LLViewerObject* LLViewerMediaFocus::getHoverObject()
void LLViewerMediaFocus::focusZoomOnMedia(LLUUID media_id)
{
LLViewerMediaImpl* impl = LLViewerMedia::getMediaImplFromTextureID(media_id);
LLViewerMediaImpl* impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(media_id);
if(impl)
{

2
indra/newview/llviewerparcelmedia.cpp
View File

@ -213,7 +213,7 @@ void LLViewerParcelMedia::play(LLParcel* parcel)
LL_DEBUGS("Media") << "new media impl with mime type " << mime_type << ", url " << media_url << LL_ENDL;
// There is no media impl, make a new one
sMediaImpl = LLViewerMedia::newMediaImpl(
sMediaImpl = LLViewerMedia::getInstance()->newMediaImpl(
placeholder_texture_id,
media_width,
media_height,

2
indra/newview/llviewertexture.cpp
View File

@ -3454,7 +3454,7 @@ void LLViewerMediaTexture::setMediaImpl()
{
if(!mMediaImplp)
{
mMediaImplp = LLViewerMedia::getMediaImplFromTextureID(mID);
mMediaImplp = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mID);
}
}

4
indra/newview/llvovolume.cpp
View File

@ -188,7 +188,7 @@ public:
virtual bool isInterestingEnough() const
{
return LLViewerMedia::isInterestingEnough(mObject, getMediaInterest());
return LLViewerMedia::getInstance()->isInterestingEnough(mObject, getMediaInterest());
}
virtual std::string getCapabilityUrl(const std::string &name) const
@ -2698,7 +2698,7 @@ void LLVOVolume::syncMediaData(S32 texture_index, const LLSD &media_data, bool m
LLUUID updating_agent = LLTextureEntry::getAgentIDFromMediaVersionString(getMediaURL());
update_from_self = (updating_agent == gAgent.getID());
}
viewer_media_t media_impl = LLViewerMedia::updateMediaImpl(mep, previous_url, update_from_self);
viewer_media_t media_impl = LLViewerMedia::getInstance()->updateMediaImpl(mep, previous_url, update_from_self);
addMediaImpl(media_impl, texture_index) ;
}

2
indra/newview/llweb.cpp
View File

@ -121,7 +121,7 @@ void LLWeb::loadURLExternal(const std::string& url, const std::string& uuid)
void LLWeb::loadURLExternal(const std::string& url, bool async, const std::string& uuid)
{
// Act like the proxy window was closed, since we won't be able to track targeted windows in the external browser.
LLViewerMedia::proxyWindowClosed(uuid);
LLViewerMedia::getInstance()->proxyWindowClosed(uuid);
if(gSavedSettings.getBOOL("DisableExternalBrowser"))
{

2
indra/newview/llwebprofile.cpp
View File

@ -83,7 +83,7 @@ void LLWebProfile::setAuthCookie(const std::string& cookie)
LLCore::HttpHeaders::ptr_t LLWebProfile::buildDefaultHeaders()
{
LLCore::HttpHeaders::ptr_t httpHeaders(new LLCore::HttpHeaders);
LLSD headers = LLViewerMedia::getHeaders();
LLSD headers = LLViewerMedia::getInstance()->getHeaders();
for (LLSD::map_iterator it = headers.beginMap(); it != headers.endMap(); ++it)
{