diff options
Diffstat (limited to 'indra/newview/llviewermedia.cpp')
| -rw-r--r-- | indra/newview/llviewermedia.cpp | 689 |
1 files changed, 391 insertions, 298 deletions
diff --git a/indra/newview/llviewermedia.cpp b/indra/newview/llviewermedia.cpp index 3eae0f8d86..ffae3c0e1f 100644 --- a/indra/newview/llviewermedia.cpp +++ b/indra/newview/llviewermedia.cpp @@ -5,21 +5,21 @@ * $LicenseInfo:firstyear=2007&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. - * + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. - * + * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. - * + * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * + * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ @@ -66,6 +66,7 @@ #include "llvoavatar.h" #include "llvoavatarself.h" #include "llvovolume.h" +#include "llfloaterreg.h" #include "llwebprofile.h" #include "llwindow.h" #include "llvieweraudio.h" @@ -167,7 +168,7 @@ public: { LL_ERRS() << "impl already has an outstanding responder" << LL_ENDL; } - + mMediaImpl->mMimeTypeProbe = this; } @@ -189,19 +190,19 @@ private: std::string mime_type = media_type.substr(0, idx1); LL_DEBUGS() << "status is " << getStatus() << ", media type \"" << media_type << "\"" << LL_ENDL; - + // 2xx status codes indicate success. // Most 4xx status codes are successful enough for our purposes. // 499 is the error code for host not found, timeout, etc. - // 500 means "Internal Server error" but we decided it's okay to + // 500 means "Internal Server error" but we decided it's okay to // accept this and go past it in the MIME type probe // 302 means the resource can be found temporarily in a different place - added this for join.secondlife.com // 499 is a code specifc to join.secondlife.com apparently safe to ignore // if( ((status >= 200) && (status < 300)) || -// ((status >= 400) && (status < 499)) || +// ((status >= 400) && (status < 499)) || // (status == 500) || // (status == 302) || -// (status == 499) +// (status == 499) // ) // We now no longer check the error code returned from the probe. // If we have a mime type, use it. If not, default to the web plugin and let it handle error reporting. @@ -229,7 +230,7 @@ private: // the call to initializeMedia may disconnect the responder, which will clear mMediaImpl. // Make a local copy so we can call loadURI() afterwards. LLViewerMediaImpl *impl = mMediaImpl; - + if(impl && !mInitialized && ! mime_type.empty()) { if(impl->initializeMedia(mime_type)) @@ -240,13 +241,13 @@ private: } } } - + public: void cancelRequest() { disconnectOwner(); } - + private: void disconnectOwner() { @@ -261,8 +262,8 @@ private: } mMediaImpl = NULL; } - - + + public: LLViewerMediaImpl *mMediaImpl; bool mInitialized; @@ -284,13 +285,12 @@ public: const LLChannelDescriptors& channels, const LLIOPipe::buffer_ptr_t& buffer) { - // We don't care about the content of the response, only the Set-Cookie header. - LL_DEBUGS("MediaAuth") << dumpResponse() - << " [headers:" << getResponseHeaders() << "]" << LL_ENDL; + const std::string url = getURL(); + const std::string& cookie = getResponseHeader(HTTP_IN_HEADER_SET_COOKIE); - + // *TODO: What about bad status codes? Does this destroy previous cookies? - LLViewerMedia::openIDCookieResponse(cookie); + LLViewerMedia::openIDCookieResponse(url, cookie); } }; @@ -313,7 +313,7 @@ public: const LLIOPipe::buffer_ptr_t& buffer) { // We don't care about the content of the response, only the set-cookie header. - LL_WARNS("MediaAuth") << dumpResponse() + LL_WARNS("MediaAuth") << dumpResponse() << " [headers:" << getResponseHeaders() << "]" << LL_ENDL; LLSD stripped_content = getResponseHeaders(); @@ -364,7 +364,7 @@ static void remove_media_impl(LLViewerMediaImpl* media) { LLViewerMedia::impl_list::iterator iter = sViewerMediaImplList.begin(); LLViewerMedia::impl_list::iterator end = sViewerMediaImplList.end(); - + for(; iter != end; iter++) { if(media == *iter) @@ -391,8 +391,8 @@ static bool sViewerMediaMuteListObserverInitialized = false; // static viewer_media_t LLViewerMedia::newMediaImpl( const LLUUID& texture_id, - S32 media_width, - S32 media_height, + S32 media_width, + S32 media_height, U8 media_auto_scale, U8 media_loop) { @@ -416,24 +416,24 @@ viewer_media_t LLViewerMedia::newMediaImpl( } viewer_media_t LLViewerMedia::updateMediaImpl(LLMediaEntry* media_entry, const std::string& previous_url, bool update_from_self) -{ +{ // 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 + + 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(); @@ -446,7 +446,7 @@ viewer_media_t LLViewerMedia::updateMediaImpl(LLMediaEntry* media_entry, const s 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()) { @@ -454,7 +454,7 @@ viewer_media_t LLViewerMedia::updateMediaImpl(LLMediaEntry* media_entry, const s { // 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; } } @@ -463,26 +463,26 @@ viewer_media_t LLViewerMedia::updateMediaImpl(LLMediaEntry* media_entry, const s // 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(); + 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") + + 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->getMediaID(), media_entry->getWidthPixels(), - media_entry->getHeightPixels(), - media_entry->getAutoScale(), + 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(); @@ -491,7 +491,7 @@ viewer_media_t LLViewerMedia::updateMediaImpl(LLMediaEntry* media_entry, const s needs_navigate = true; } } - + if(media_impl) { if(needs_navigate) @@ -510,7 +510,7 @@ viewer_media_t LLViewerMedia::updateMediaImpl(LLMediaEntry* media_entry, const s LL_DEBUGS() << "updating URL in the media impl to " << media_impl->mMediaEntryURL << LL_ENDL; } } - + return media_impl; } @@ -519,7 +519,7 @@ viewer_media_t LLViewerMedia::updateMediaImpl(LLMediaEntry* media_entry, const s LLViewerMediaImpl* LLViewerMedia::getMediaImplFromTextureID(const LLUUID& texture_id) { 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()) @@ -534,7 +534,7 @@ LLViewerMediaImpl* LLViewerMedia::getMediaImplFromTextureID(const LLUUID& textur // static std::string LLViewerMedia::getCurrentUserAgent() { - // Don't use user-visible string to avoid + // Don't use user-visible string to avoid // punctuation and strange characters. std::string skin_name = gSavedSettings.getString("SkinCurrent"); @@ -553,7 +553,7 @@ std::string LLViewerMedia::getCurrentUserAgent() codec << LLVersionInfo::getVersion(); codec << " (" << channel << "; " << skin_name << " skin)"; LL_INFOS() << codec.str() << LL_ENDL; - + return codec.str(); } @@ -562,7 +562,7 @@ std::string LLViewerMedia::getCurrentUserAgent() void LLViewerMedia::updateBrowserUserAgent() { std::string user_agent = getCurrentUserAgent(); - + impl_list::iterator iter = sViewerMediaImplList.begin(); impl_list::iterator end = sViewerMediaImplList.end(); @@ -651,7 +651,7 @@ void LLViewerMedia::muteListChanged() bool LLViewerMedia::isInterestingEnough(const LLVOVolume *object, const F64 &object_interest) { bool result = false; - + if (NULL == object) { result = false; @@ -667,13 +667,13 @@ bool LLViewerMedia::isInterestingEnough(const LLVOVolume *object, const F64 &obj { result = true; } - else + else { LL_DEBUGS() << "object interest = " << object_interest << ", lowest loadable = " << sLowestLoadableImplInterest << LL_ENDL; if(object_interest >= sLowestLoadableImplInterest) result = true; } - + return result; } @@ -780,13 +780,13 @@ static LLTrace::BlockTimerStatHandle FTM_MEDIA_MISC("Misc"); void LLViewerMedia::updateMedia(void *dummy_arg) { LL_RECORD_BLOCK_TIME(FTM_MEDIA_UPDATE); - + // Enable/disable the plugin read thread LLPluginProcessParent::setUseReadThread(gSavedSettings.getBOOL("PluginUseReadThread")); - + // HACK: we always try to keep a spare running webkit plugin around to improve launch times. createSpareBrowserMediaSource(); - + sAnyMediaShowing = false; sUpdatedCookies = getCookieStore()->getChangedCookies(); if(!sUpdatedCookies.empty()) @@ -794,7 +794,7 @@ void LLViewerMedia::updateMedia(void *dummy_arg) LL_DEBUGS() << "updated cookies will be sent to all loaded plugins: " << LL_ENDL; LL_DEBUGS() << sUpdatedCookies << LL_ENDL; } - + impl_list::iterator iter = sViewerMediaImplList.begin(); impl_list::iterator end = sViewerMediaImplList.end(); @@ -807,14 +807,14 @@ void LLViewerMedia::updateMedia(void *dummy_arg) pimpl->calculateInterest(); } } - + // Let the spare media source actually launch if(sSpareBrowserMediaSource) { LL_RECORD_BLOCK_TIME(FTM_MEDIA_SPARE_IDLE); sSpareBrowserMediaSource->idle(); } - + { LL_RECORD_BLOCK_TIME(FTM_MEDIA_SORT); // Sort the static instance list using our interest criteria @@ -824,14 +824,14 @@ void LLViewerMedia::updateMedia(void *dummy_arg) // 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; - + std::vector<LLViewerMediaImpl*> proximity_order; - + bool inworld_media_enabled = gSavedSettings.getBOOL("AudioStreamingMedia"); bool inworld_audio_enabled = gSavedSettings.getBOOL("AudioStreamingMusic"); U32 max_instances = gSavedSettings.getU32("PluginInstancesTotal"); @@ -840,19 +840,19 @@ void LLViewerMedia::updateMedia(void *dummy_arg) 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; - + // 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_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)) @@ -883,7 +883,7 @@ void LLViewerMedia::updateMedia(void *dummy_arg) 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; @@ -897,7 +897,7 @@ void LLViewerMedia::updateMedia(void *dummy_arg) { 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. @@ -919,11 +919,11 @@ void LLViewerMedia::updateMedia(void *dummy_arg) // 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)); } } @@ -933,18 +933,18 @@ void LLViewerMedia::updateMedia(void *dummy_arg) 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? */ + if (!gViewerWindow->getActive() /* viewer window minimized? */ && new_priority > LLPluginClassMedia::PRIORITY_HIDDEN) { new_priority = LLPluginClassMedia::PRIORITY_HIDDEN; @@ -954,7 +954,7 @@ void LLViewerMedia::updateMedia(void *dummy_arg) { new_priority = LLPluginClassMedia::PRIORITY_LOW; } - + if(!inworld_media_enabled) { // If inworld media is locked out, force all inworld media to stay unloaded. @@ -972,7 +972,7 @@ 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. @@ -984,7 +984,7 @@ void LLViewerMedia::updateMedia(void *dummy_arg) } total_cpu += pimpl->getCPUUsage(); - + if (!pimpl->getUsedInUI() && pimpl->hasMedia()) { sAnyMediaShowing = true; @@ -1008,7 +1008,7 @@ void LLViewerMedia::updateMedia(void *dummy_arg) sLowestLoadableImplInterest = object->getPixelArea(); } } - + if(gSavedSettings.getBOOL("MediaPerformanceManagerDebug")) { // Give impls the same ordering as the priority list @@ -1017,7 +1017,7 @@ void LLViewerMedia::updateMedia(void *dummy_arg) else { LL_RECORD_BLOCK_TIME(FTM_MEDIA_SORT2); - // Use a distance-based sort for proximity values. + // Use a distance-based sort for proximity values. std::stable_sort(proximity_order.begin(), proximity_order.end(), proximity_comparitor); } @@ -1026,7 +1026,7 @@ void LLViewerMedia::updateMedia(void *dummy_arg) { proximity_order[i]->mProximity = i; } - + LL_DEBUGS("PluginPriority") << "Total reported CPU usage is " << total_cpu << LL_ENDL; } @@ -1045,11 +1045,11 @@ 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 + + // Then impl_list::iterator iter = sViewerMediaImplList.begin(); impl_list::iterator end = sViewerMediaImplList.end(); - + for(; iter != end; iter++) { LLViewerMediaImpl* pimpl = *iter; @@ -1058,18 +1058,18 @@ void LLViewerMedia::setAllMediaEnabled(bool val) pimpl->setDisabled(!val); } } - + // Also do Parcel Media and Parcel Audio if (val) { if (!LLViewerMedia::isParcelMediaPlaying() && LLViewerMedia::hasParcelMedia()) - { + { LLViewerParcelMedia::play(LLViewerParcelMgr::getInstance()->getAgentParcel()); } - + if (gSavedSettings.getBOOL("AudioStreamingMusic") && !LLViewerMedia::isParcelAudioPlaying() && - gAudiop && + gAudiop && LLViewerMedia::hasParcelAudio()) { if (LLAudioEngine::AUDIO_PAUSED == gAudiop->isInternetStreamPlaying()) @@ -1142,26 +1142,26 @@ void LLViewerMedia::clearAllCookies() pimpl->mMediaSource->clear_cookies(); } } - + // Clear all cookies from the cookie store getCookieStore()->setAllCookies(""); // FIXME: this may not be sufficient, since the on-disk cookie file won't get written until some browser instance exits cleanly. // It also won't clear cookies for other accounts, or for any account if we're not logged in, and won't do anything at all if there are no webkit plugins loaded. // Until such time as we can centralize cookie storage, the following hack should cover these cases: - + // HACK: Look for cookie files in all possible places and delete them. // NOTE: this assumes knowledge of what happens inside the webkit plugin (it's what adds 'browser_profile' to the path and names the cookie file) - + // Places that cookie files can be: // <getOSUserAppDir>/browser_profile/cookies // <getOSUserAppDir>/first_last/browser_profile/cookies (note that there may be any number of these!) // <getOSUserAppDir>/first_last/plugin_cookies.txt (note that there may be any number of these!) - + std::string base_dir = gDirUtilp->getOSUserAppDir() + gDirUtilp->getDirDelimiter(); std::string target; std::string filename; - + LL_DEBUGS() << "base dir = " << base_dir << LL_ENDL; // The non-logged-in version is easy @@ -1174,7 +1174,7 @@ void LLViewerMedia::clearAllCookies() { LLFile::remove(target); } - + // the hard part: iterate over all user directories and delete the cookie file from each one LLDirIterator dir_iter(base_dir, "*_*"); while (dir_iter.next(filename)) @@ -1184,26 +1184,26 @@ void LLViewerMedia::clearAllCookies() gDirUtilp->append(target, "cookies"); LL_DEBUGS() << "target = " << target << LL_ENDL; if(LLFile::isfile(target)) - { + { LLFile::remove(target); } - + // Other accounts may have new-style cookie files too -- delete them as well target = gDirUtilp->add(base_dir, filename); gDirUtilp->append(target, PLUGIN_COOKIE_FILE_NAME); LL_DEBUGS() << "target = " << target << LL_ENDL; if(LLFile::isfile(target)) - { + { LLFile::remove(target); } } - + // If we have an OpenID cookie, re-add it to the cookie store. - setOpenIDCookie(); + setOpenIDCookie(std::string()); } - + ///////////////////////////////////////////////////////////////////////////////////////// -// static +// static void LLViewerMedia::clearAllCaches() { // Clear all plugins' caches @@ -1215,9 +1215,9 @@ void LLViewerMedia::clearAllCaches() pimpl->clearCache(); } } - + ///////////////////////////////////////////////////////////////////////////////////////// -// static +// static void LLViewerMedia::setCookiesEnabled(bool enabled) { // Set the "cookies enabled" flag for all loaded plugins @@ -1232,9 +1232,9 @@ void LLViewerMedia::setCookiesEnabled(bool enabled) } } } - + ///////////////////////////////////////////////////////////////////////////////////////// -// static +// static void LLViewerMedia::setProxyConfig(bool enable, const std::string &host, int port) { // Set the proxy config for all loaded plugins @@ -1251,7 +1251,7 @@ void LLViewerMedia::setProxyConfig(bool enable, const std::string &host, int por } ///////////////////////////////////////////////////////////////////////////////////////// -// static +// static ///////////////////////////////////////////////////////////////////////////////////////// // static LLPluginCookieStore *LLViewerMedia::getCookieStore() @@ -1260,7 +1260,7 @@ LLPluginCookieStore *LLViewerMedia::getCookieStore() { sCookieStore = new LLPluginCookieStore; } - + return sCookieStore; } @@ -1276,7 +1276,7 @@ void LLViewerMedia::loadCookieFile() LL_INFOS() << "can't get path to plugin cookie file - probably not logged in yet." << LL_ENDL; return; } - + // open the file for reading llifstream file(resolved_filename.c_str()); if (!file.is_open()) @@ -1284,11 +1284,11 @@ void LLViewerMedia::loadCookieFile() LL_WARNS() << "can't load plugin cookies from file \"" << PLUGIN_COOKIE_FILE_NAME << "\"" << LL_ENDL; return; } - + getCookieStore()->readAllCookies(file, true); file.close(); - + // send the clear_cookies message to all loaded plugins impl_list::iterator iter = sViewerMediaImplList.begin(); impl_list::iterator end = sViewerMediaImplList.end(); @@ -1300,9 +1300,9 @@ void LLViewerMedia::loadCookieFile() pimpl->mMediaSource->clear_cookies(); } } - + // If we have an OpenID cookie, re-add it to the cookie store. - setOpenIDCookie(); + setOpenIDCookie(std::string()); } @@ -1337,23 +1337,23 @@ void LLViewerMedia::saveCookieFile() void LLViewerMedia::addCookie(const std::string &name, const std::string &value, const std::string &domain, const LLDate &expires, const std::string &path, bool secure) { std::stringstream cookie; - + cookie << name << "=" << LLPluginCookieStore::quoteString(value); - + if(expires.notNull()) { cookie << "; expires=" << expires.asRFC1123(); } - + cookie << "; domain=" << domain; cookie << "; path=" << path; - + if(secure) { cookie << "; secure"; } - + getCookieStore()->setCookies(cookie.str()); } @@ -1370,7 +1370,7 @@ void LLViewerMedia::addSessionCookie(const std::string &name, const std::string void LLViewerMedia::removeCookie(const std::string &name, const std::string &domain, const std::string &path ) { // To remove a cookie, add one with the same name, domain, and path that expires in the past. - + addCookie(name, "", domain, LLDate(LLDate::now().secondsSinceEpoch() - 1.0), path); } @@ -1388,9 +1388,34 @@ LLSD LLViewerMedia::getHeaders() 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("="); + 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; + + return true; + } + } + + return false; +} + + ///////////////////////////////////////////////////////////////////////////////////////// // static -void LLViewerMedia::setOpenIDCookie() +void LLViewerMedia::setOpenIDCookie(const std::string& url) { if(!sOpenIDCookie.empty()) { @@ -1398,7 +1423,7 @@ void LLViewerMedia::setOpenIDCookie() // 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::size_type host_start = authority.find('@'); + std::string::size_type host_start = authority.find('@'); if(host_start == std::string::npos) { // no username/password @@ -1406,20 +1431,43 @@ void LLViewerMedia::setOpenIDCookie() } else { - // 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.) ++host_start; } - std::string::size_type host_end = authority.rfind(':'); + std::string::size_type host_end = authority.rfind(':'); if((host_end == std::string::npos) || (host_end < host_start)) { // no port host_end = authority.size(); } - + getCookieStore()->setCookiesFromHost(sOpenIDCookie, authority.substr(host_start, host_end - host_start)); - // Do a web profile get so we can store the cookie + if (url.length()) + { + LLMediaCtrl* media_instance = LLFloaterReg::getInstance("destinations")->getChild<LLMediaCtrl>("destination_guide_contents"); + if (media_instance) + { + std::string cookie_host = authority.substr(host_start, host_end - host_start); + std::string cookie_name = ""; + std::string cookie_value = ""; + std::string cookie_path = ""; + bool httponly = true; + bool secure = true; + if (parseRawCookie(sOpenIDCookie, cookie_name, cookie_value, cookie_path, httponly, secure) && + media_instance->getMediaPlugin()) + { + media_instance->getMediaPlugin()->setCookie(url, cookie_name, cookie_value, cookie_host, cookie_path, httponly, secure); + } + } + } + + // NOTE: this is the original OpenID cookie code, so of which is no longer needed now that we + // are using CEF - it's very intertwined with other code so, for the moment, I'm going to + // leave it alone and make a task to come back to it once we're sure the CEF cookie code is robust. + + // Do a web profile get so we can store the cookie LLSD headers = LLSD::emptyMap(); headers[HTTP_OUT_HEADER_ACCEPT] = "*/*"; headers[HTTP_OUT_HEADER_COOKIE] = sOpenIDCookie; @@ -1430,7 +1478,7 @@ void LLViewerMedia::setOpenIDCookie() LL_DEBUGS("MediaAuth") << "Requesting " << profile_url << LL_ENDL; LL_DEBUGS("MediaAuth") << "sOpenIDCookie = [" << sOpenIDCookie << "]" << LL_ENDL; - LLHTTPClient::get(profile_url, + LLHTTPClient::get(profile_url, new LLViewerMediaWebProfileResponder(raw_profile_url.getAuthority()), headers); } @@ -1442,12 +1490,12 @@ void LLViewerMedia::openIDSetup(const std::string &openid_url, const std::string { LL_DEBUGS("MediaAuth") << "url = \"" << openid_url << "\", token = \"" << openid_token << "\"" << LL_ENDL; - // 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. sOpenIDURL.init(openid_url.c_str()); - + // We shouldn't ever do this twice, but just in case this code gets repurposed later, clear existing cookies. sOpenIDCookie.clear(); @@ -1462,24 +1510,24 @@ void LLViewerMedia::openIDSetup(const std::string &openid_url, const std::string U8 *data = new U8[size]; memcpy(data, openid_token.data(), size); - LLHTTPClient::postRaw( - openid_url, - data, - size, + LLHTTPClient::postRaw( + openid_url, + data, + size, new LLViewerMediaOpenIDResponder(), headers); - + } ///////////////////////////////////////////////////////////////////////////////////////// // static -void LLViewerMedia::openIDCookieResponse(const std::string &cookie) +void LLViewerMedia::openIDCookieResponse(const std::string& url, const std::string &cookie) { LL_DEBUGS("MediaAuth") << "Cookie received: \"" << cookie << "\"" << LL_ENDL; - + sOpenIDCookie += cookie; - setOpenIDCookie(); + setOpenIDCookie(url); } ///////////////////////////////////////////////////////////////////////////////////////// @@ -1488,7 +1536,7 @@ void LLViewerMedia::proxyWindowOpened(const std::string &target, const std::stri { if(uuid.empty()) return; - + for (impl_list::iterator iter = sViewerMediaImplList.begin(); iter != sViewerMediaImplList.end(); iter++) { if((*iter)->mMediaSource && (*iter)->mMediaSource->pluginSupportsMediaBrowser()) @@ -1525,7 +1573,7 @@ void LLViewerMedia::createSpareBrowserMediaSource() if (!sSpareBrowserMediaSource && !gSavedSettings.getBOOL("PluginAttachDebuggerToPlugins")) { // The null owner will keep the browser plugin from fully initializing - // (specifically, it keeps LLPluginClassMedia from negotiating a size change, + // (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); } @@ -1537,7 +1585,7 @@ LLPluginClassMedia* LLViewerMedia::getSpareBrowserMediaSource() { LLPluginClassMedia* result = sSpareBrowserMediaSource; sSpareBrowserMediaSource = NULL; - return result; + return result; }; bool LLViewerMedia::hasInWorldMedia() @@ -1626,12 +1674,12 @@ void LLViewerMedia::setOnlyAudibleMediaTextureID(const LLUUID& texture_id) ////////////////////////////////////////////////////////////////////////////////////////// // LLViewerMediaImpl ////////////////////////////////////////////////////////////////////////////////////////// -LLViewerMediaImpl::LLViewerMediaImpl( const LLUUID& texture_id, - S32 media_width, - S32 media_height, - U8 media_auto_scale, +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), @@ -1672,7 +1720,7 @@ LLViewerMediaImpl::LLViewerMediaImpl( const LLUUID& texture_id, mTrustedBrowser(false), mZoomFactor(1.0), mCleanBrowser(false) -{ +{ // Set up the mute list observer if it hasn't been set up already. if(!sViewerMediaMuteListObserverInitialized) @@ -1680,11 +1728,11 @@ LLViewerMediaImpl::LLViewerMediaImpl( const LLUUID& texture_id, LLMuteList::getInstance()->addObserver(&sViewerMediaMuteListObserver); sViewerMediaMuteListObserverInitialized = true; } - + add_media_impl(this); 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. LLViewerMediaTexture* media_tex = LLViewerTextureManager::getMediaTexture(mTextureId); @@ -1699,7 +1747,7 @@ LLViewerMediaImpl::LLViewerMediaImpl( const LLUUID& texture_id, LLViewerMediaImpl::~LLViewerMediaImpl() { destroyMediaSource(); - + LLViewerMediaTexture::removeMediaImplFromTexture(mTextureId) ; setTextureID(); @@ -1711,7 +1759,7 @@ void LLViewerMediaImpl::emitEvent(LLPluginClassMedia* plugin, LLViewerMediaObser { // 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()) @@ -1727,7 +1775,7 @@ bool LLViewerMediaImpl::initializeMedia(const std::string& 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. @@ -1750,7 +1798,7 @@ void LLViewerMediaImpl::createMediaSource() // This media shouldn't be created yet. return; } - + if(! mMediaURL.empty()) { navigateInternal(); @@ -1776,15 +1824,15 @@ void LLViewerMediaImpl::destroyMediaSource() { oldImage->setPlaying(FALSE) ; } - + cancelMimeTypeProbe(); - + if(mMediaSource) { mMediaSource->setDeleteOK(true) ; delete mMediaSource; mMediaSource = NULL; - } + } } ////////////////////////////////////////////////////////////////////////////////////////// @@ -1799,11 +1847,11 @@ LLPluginClassMedia* LLViewerMediaImpl::newSourceFromMediaType(std::string media_ { 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. // Do not use a spare if launching with full viewer control (e.g. Facebook, Twitter and few others) - if ((plugin_basename == "media_plugin_webkit") && + if ((plugin_basename == "media_plugin_cef") && !gSavedSettings.getBOOL("PluginAttachDebuggerToPlugins") && !clean_browser) { media_source = LLViewerMedia::getSpareBrowserMediaSource(); @@ -1812,7 +1860,7 @@ LLPluginClassMedia* LLViewerMediaImpl::newSourceFromMediaType(std::string media_ media_source->setOwner(owner); media_source->setTarget(target); media_source->setSize(default_width, default_height); - + return media_source; } } @@ -1824,8 +1872,12 @@ LLPluginClassMedia* LLViewerMediaImpl::newSourceFromMediaType(std::string media_ { std::string launcher_name = gDirUtilp->getLLPluginLauncher(); std::string plugin_name = gDirUtilp->getLLPluginFilename(plugin_basename); - std::string user_data_path = gDirUtilp->getOSUserAppDir(); - user_data_path += gDirUtilp->getDirDelimiter(); + + std::string user_data_path_cache = gDirUtilp->getCacheDir(false); + user_data_path_cache += gDirUtilp->getDirDelimiter(); + + std::string user_data_path_cookies = gDirUtilp->getOSUserAppDir(); + user_data_path_cookies += gDirUtilp->getDirDelimiter(); // Fix for EXT-5960 - make browser profile specific to user (cache, cookies etc.) // If the linden username returned is blank, that can only mean we are @@ -1836,8 +1888,8 @@ LLPluginClassMedia* LLViewerMediaImpl::newSourceFromMediaType(std::string media_ if ( ! linden_user_dir.empty() ) { // gDirUtilp->getLindenUserDir() is whole path, not just Linden name - user_data_path = linden_user_dir; - user_data_path += gDirUtilp->getDirDelimiter(); + user_data_path_cookies = linden_user_dir; + user_data_path_cookies += gDirUtilp->getDirDelimiter(); }; // See if the plugin executable exists @@ -1854,7 +1906,7 @@ LLPluginClassMedia* LLViewerMediaImpl::newSourceFromMediaType(std::string media_ { media_source = new LLPluginClassMedia(owner); media_source->setSize(default_width, default_height); - media_source->setUserDataPath(user_data_path); + media_source->setUserDataPath(user_data_path_cache, user_data_path_cookies); media_source->setLanguageCode(LLUI::getLanguage()); // collect 'cookies enabled' setting from prefs and send to embedded browser @@ -1868,12 +1920,15 @@ LLPluginClassMedia* LLViewerMediaImpl::newSourceFromMediaType(std::string media_ // collect 'javascript enabled' setting from prefs and send to embedded browser bool javascript_enabled = gSavedSettings.getBOOL( "BrowserJavascriptEnabled" ); media_source->setJavascriptEnabled( javascript_enabled || clean_browser); - + 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::getCurrentUserAgent()); + media_source->setTarget(target); - + const std::string plugin_dir = gDirUtilp->getLLPluginDir(); if (media_source->init(launcher_name, plugin_dir, plugin_name, gSavedSettings.getBOOL("PluginAttachDebuggerToPlugins"))) { @@ -1886,14 +1941,14 @@ LLPluginClassMedia* LLViewerMediaImpl::newSourceFromMediaType(std::string media_ } } } - + LL_WARNS_ONCE("Plugin") << "plugin initialization failed for mime type: " << media_type << LL_ENDL; LLSD args; args["MIME_TYPE"] = media_type; LLNotificationsUtil::add("NoPlugin", args); return NULL; -} +} ////////////////////////////////////////////////////////////////////////////////////////// bool LLViewerMediaImpl::initializePlugin(const std::string& media_type) @@ -1904,10 +1959,10 @@ bool LLViewerMediaImpl::initializePlugin(const std::string& media_type) mMediaWidth = mMediaSource->getSetWidth(); mMediaHeight = mMediaSource->getSetHeight(); } - + // Always delete the old media impl first. destroyMediaSource(); - + // and unconditionally set the mime type mMimeType = media_type; @@ -1915,7 +1970,7 @@ bool LLViewerMediaImpl::initializePlugin(const std::string& media_type) { // This impl should not be loaded at this time. LL_DEBUGS("PluginPriority") << this << "Not loading (PRIORITY_UNLOADED)" << LL_ENDL; - + return false; } @@ -1926,7 +1981,7 @@ bool LLViewerMediaImpl::initializePlugin(const std::string& media_type) mCurrentMimeType = mMimeType; LLPluginClassMedia* media_source = newSourceFromMediaType(mMimeType, this, mMediaWidth, mMediaHeight, mTarget, mCleanBrowser); - + if (media_source) { media_source->setDisableTimeout(gSavedSettings.getBOOL("DebugPluginDisableTimeout")); @@ -1935,7 +1990,7 @@ bool LLViewerMediaImpl::initializePlugin(const std::string& media_type) media_source->setBrowserUserAgent(LLViewerMedia::getCurrentUserAgent()); media_source->focus(mHasFocus); media_source->setBackgroundColor(mBackgroundColor); - + if(gSavedSettings.getBOOL("BrowserIgnoreSSLCertErrors")) { media_source->ignore_ssl_cert_errors(true); @@ -1943,19 +1998,19 @@ bool LLViewerMediaImpl::initializePlugin(const std::string& media_type) // the correct way to deal with certs it to load ours from CA.pem and append them to the ones // Qt/WebKit loads from your system location. - // Note: This needs the new CA.pem file with the Equifax Secure Certificate Authority + // Note: This needs the new CA.pem file with the Equifax Secure Certificate Authority // cert at the bottom: (MIIDIDCCAomgAwIBAgIENd70zzANBg) std::string ca_path = gDirUtilp->getExpandedFilename( LL_PATH_APP_SETTINGS, "CA.pem" ); media_source->addCertificateFilePath( ca_path ); media_source->proxy_setup(gSavedSettings.getBOOL("BrowserProxyEnabled"), gSavedSettings.getString("BrowserProxyAddress"), gSavedSettings.getS32("BrowserProxyPort")); - + if(mClearCache) { mClearCache = false; media_source->clear_cache(); } - + // TODO: Only send cookies to plugins that need them // Ideally, the plugin should tell us whether it handles cookies or not -- either via the init response or through a separate message. // Due to the ordering of messages, it's possible we wouldn't get that information back in time to send cookies before sending a navigate message, @@ -1966,7 +2021,7 @@ bool LLViewerMediaImpl::initializePlugin(const std::string& media_type) { media_source->set_cookies(all_cookies); } - + mMediaSource = media_source; mMediaSource->setDeleteOK(false) ; updateVolume(); @@ -2009,16 +2064,16 @@ void LLViewerMediaImpl::loadURI() std::string sanitized_uri = (u.query().empty() ? uri : u.scheme() + "://" + u.authority() + u.path()); LL_INFOS() << "Asking media source to load URI: " << sanitized_uri << LL_ENDL; } - + mMediaSource->loadURI( uri ); - - // A non-zero mPreviousMediaTime means that either this media was previously unloaded by the priority code while playing/paused, + + // 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. @@ -2071,11 +2126,11 @@ void LLViewerMediaImpl::play() // 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(); } - + // always start the media start(); } @@ -2176,10 +2231,10 @@ void LLViewerMediaImpl::updateVolume() { if(mMediaSource) { - // always scale the volume by the global media volume + // always scale the volume by the global media volume F32 volume = mRequestedVolume * LLViewerMedia::getVolume(); - if (mProximityCamera > 0) + if (mProximityCamera > 0) { if (mProximityCamera > gSavedSettings.getF32("MediaRollOffMax")) { @@ -2218,7 +2273,7 @@ F32 LLViewerMediaImpl::getVolume() void LLViewerMediaImpl::focus(bool focus) { mHasFocus = focus; - + if (mMediaSource) { // call focus just for the hell of it, even though this apopears to be a nop @@ -2246,7 +2301,7 @@ std::string LLViewerMediaImpl::getCurrentMediaURL() { return mCurrentMediaURL; } - + return mMediaURL; } @@ -2314,17 +2369,17 @@ void LLViewerMediaImpl::mouseMove(S32 x, S32 y, MASK mask) } ////////////////////////////////////////////////////////////////////////////////////////// -//static +//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]; - + // 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; @@ -2352,7 +2407,7 @@ void LLViewerMediaImpl::mouseDown(const LLVector2& texture_coords, MASK mask, S3 void LLViewerMediaImpl::mouseUp(const LLVector2& texture_coords, MASK mask, S32 button) { if(mMediaSource) - { + { S32 x, y; scaleTextureCoords(texture_coords, &x, &y); @@ -2363,7 +2418,7 @@ void LLViewerMediaImpl::mouseUp(const LLVector2& texture_coords, MASK mask, S32 void LLViewerMediaImpl::mouseMove(const LLVector2& texture_coords, MASK mask) { if(mMediaSource) - { + { S32 x, y; scaleTextureCoords(texture_coords, &x, &y); @@ -2371,6 +2426,17 @@ void LLViewerMediaImpl::mouseMove(const LLVector2& texture_coords, MASK mask) } } +void LLViewerMediaImpl::mouseDoubleClick(const LLVector2& texture_coords, MASK mask) +{ + if (mMediaSource) + { + S32 x, y; + scaleTextureCoords(texture_coords, &x, &y); + + mouseDoubleClick(x, y, mask); + } +} + ////////////////////////////////////////////////////////////////////////////////////////// void LLViewerMediaImpl::mouseDoubleClick(S32 x, S32 y, MASK mask, S32 button) { @@ -2405,18 +2471,18 @@ void LLViewerMediaImpl::onMouseCaptureLost() } ////////////////////////////////////////////////////////////////////////////////////////// -BOOL LLViewerMediaImpl::handleMouseUp(S32 x, S32 y, MASK mask) -{ +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. - + if(hasMouseCapture()) { // Release the mouse -- this will also send a mouseup to the media gFocusMgr.setMouseCapture( FALSE ); } - return TRUE; + return TRUE; } ////////////////////////////////////////////////////////////////////////////////////////// @@ -2492,14 +2558,14 @@ void LLViewerMediaImpl::updateJavascriptObject() } ////////////////////////////////////////////////////////////////////////////////////////// -const std::string& LLViewerMediaImpl::getName() const -{ +const std::string& LLViewerMediaImpl::getName() const +{ if (mMediaSource) { return mMediaSource->getMediaName(); } - - return LLStringUtil::null; + + return LLStringUtil::null; }; ////////////////////////////////////////////////////////////////////////////////////////// @@ -2555,21 +2621,21 @@ void LLViewerMediaImpl::navigateTo(const std::string& url, const std::string& mi // Don't carry media play state across distinct URLs. resetPreviousMediaState(); } - + // 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(); - + // 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; - + // An explicit navigate resets the "failed" flag. mMediaSourceFailed = false; @@ -2585,7 +2651,7 @@ void LLViewerMediaImpl::navigateTo(const std::string& url, const std::string& mi // This impl should not be loaded at this time. LL_DEBUGS("PluginPriority") << this << "Not loading (PRIORITY_UNLOADED)" << LL_ENDL; - + return; } @@ -2609,13 +2675,13 @@ void LLViewerMediaImpl::navigateInternal() mNavigateSuspendedDeferred = true; return; } - + if(mMimeTypeProbe != NULL) { LL_WARNS() << "MIME type probe already in progress -- bailing out." << LL_ENDL; return; } - + if(mNavigateServerRequest) { setNavState(MEDIANAVSTATE_SERVER_SENT); @@ -2624,12 +2690,12 @@ void LLViewerMediaImpl::navigateInternal() { 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); @@ -2698,27 +2764,47 @@ void LLViewerMediaImpl::navigateStop() bool LLViewerMediaImpl::handleKeyHere(KEY key, MASK mask) { 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 (!result) + { + LLSD native_key_data = gViewerWindow->getWindow()->getNativeKeyData(); + result = mMediaSource->keyEvent(LLPluginClassMedia::KEY_EVENT_DOWN, key, mask, native_key_data); + } + } + + return result; +} + +////////////////////////////////////////////////////////////////////////////////////////// +bool LLViewerMediaImpl::handleKeyUpHere(KEY key, MASK mask) +{ + 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) + 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); - // Since the viewer internal event dispatching doesn't give us key-up events, simulate one here. - (void)mMediaSource->keyEvent(LLPluginClassMedia::KEY_EVENT_UP ,key, mask, native_key_data); + result = mMediaSource->keyEvent(LLPluginClassMedia::KEY_EVENT_UP, key, mask, native_key_data); } } - + return result; } @@ -2726,7 +2812,7 @@ bool LLViewerMediaImpl::handleKeyHere(KEY key, MASK mask) bool LLViewerMediaImpl::handleUnicodeCharHere(llwchar uni_char) { bool result = false; - + if (mMediaSource) { // only accept 'printable' characters, sigh... @@ -2734,11 +2820,11 @@ bool LLViewerMediaImpl::handleUnicodeCharHere(llwchar uni_char) && 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); } } - + return result; } @@ -2817,15 +2903,15 @@ void LLViewerMediaImpl::update() } } - + if(mMediaSource == NULL) { return; } - + // Make sure a navigate doesn't happen during the idle -- it can cause mMediaSource to get destroyed, which can cause a crash. setNavigateSuspended(true); - + mMediaSource->idle(); setNavigateSuspended(false); @@ -2834,7 +2920,7 @@ void LLViewerMediaImpl::update() { return; } - + if(mMediaSource->isPluginExited()) { resetPreviousMediaState(); @@ -2846,18 +2932,18 @@ void LLViewerMediaImpl::update() { return; } - + if(mSuspendUpdates || !mVisible) { return; } - + LLViewerMediaTexture* placeholder_image = updatePlaceholderImage(); - + if(placeholder_image) { LLRect dirty_rect; - + // Since we're updating this texture, we know it's playing. Tell the texture to do its replacement magic so it gets rendered. placeholder_image->setPlaying(TRUE); @@ -2868,7 +2954,7 @@ void LLViewerMediaImpl::update() S32 y_pos = llmax(dirty_rect.mBottom, 0); S32 width = llmin(dirty_rect.mRight, placeholder_image->getWidth()) - x_pos; S32 height = llmin(dirty_rect.mTop, placeholder_image->getHeight()) - y_pos; - + if(width > 0 && height > 0) { @@ -2881,21 +2967,21 @@ void LLViewerMediaImpl::update() // Offset the pixels pointer to match x_pos and y_pos data += ( x_pos * mMediaSource->getTextureDepth() * mMediaSource->getBitsWidth() ); data += ( y_pos * mMediaSource->getTextureDepth() ); - + { LL_RECORD_BLOCK_TIME(FTM_MEDIA_SET_SUBIMAGE); placeholder_image->setSubImage( - data, - mMediaSource->getBitsWidth(), + data, + mMediaSource->getBitsWidth(), mMediaSource->getBitsHeight(), - x_pos, - y_pos, - width, + x_pos, + y_pos, + width, height); } } - + mMediaSource->resetDirty(); } } @@ -2916,10 +3002,10 @@ LLViewerMediaTexture* LLViewerMediaImpl::updatePlaceholderImage() // The code that created this instance will read from the plugin's bits. return NULL; } - + LLViewerMediaTexture* placeholder_image = LLViewerTextureManager::getMediaTexture( mTextureId ); - - if (mNeedsNewTexture + + if (mNeedsNewTexture || placeholder_image->getUseMipMaps() || (placeholder_image->getWidth() != mMediaSource->getTextureWidth()) || (placeholder_image->getHeight() != mMediaSource->getTextureHeight()) @@ -2933,7 +3019,7 @@ LLViewerMediaTexture* LLViewerMediaImpl::updatePlaceholderImage() int texture_width = mMediaSource->getTextureWidth(); int texture_height = mMediaSource->getTextureHeight(); int texture_depth = mMediaSource->getTextureDepth(); - + // MEDIAOPT: check to see if size actually changed before doing work placeholder_image->destroyGLTexture(); // MEDIAOPT: apparently just calling setUseMipMaps(FALSE) doesn't work? @@ -2959,13 +3045,13 @@ LLViewerMediaTexture* LLViewerMediaImpl::updatePlaceholderImage() // FIXME // placeholder_image->mIsMediaTexture = true; mNeedsNewTexture = false; - - // If the amount of the texture being drawn by the media goes down in either width or height, + + // If the amount of the texture being drawn by the media goes down in either width or height, // recreate the texture to avoid leaving parts of the old image behind. mTextureUsedWidth = mMediaSource->getWidth(); mTextureUsedHeight = mMediaSource->getHeight(); } - + return placeholder_image; } @@ -2980,14 +3066,14 @@ LLUUID LLViewerMediaImpl::getMediaTextureID() const void LLViewerMediaImpl::setVisible(bool visible) { mVisible = visible; - + if(mVisible) { if(mMediaSource && mMediaSource->isPluginExited()) { destroyMediaSource(); } - + if(!mMediaSource) { createMediaSource(); @@ -3021,12 +3107,12 @@ void LLViewerMediaImpl::scaleMouse(S32 *mouse_x, S32 *mouse_y) bool LLViewerMediaImpl::isMediaTimeBased() { bool result = false; - + if(mMediaSource) { result = mMediaSource->pluginSupportsMediaTime(); } - + return result; } @@ -3034,14 +3120,14 @@ bool LLViewerMediaImpl::isMediaTimeBased() bool LLViewerMediaImpl::isMediaPlaying() { bool result = false; - + if(mMediaSource) { EMediaStatus status = mMediaSource->getStatus(); if(status == MEDIA_PLAYING || status == MEDIA_LOADING) result = true; } - + return result; } ////////////////////////////////////////////////////////////////////////////////////////// @@ -3054,7 +3140,7 @@ bool LLViewerMediaImpl::isMediaPaused() if(mMediaSource->getStatus() == MEDIA_PAUSED) result = true; } - + return result; } @@ -3082,7 +3168,7 @@ void LLViewerMediaImpl::setDisabled(bool disabled, bool forcePlayOnEnable) { // Only do this on actual state transitions. mIsDisabled = disabled; - + if(mIsDisabled) { // We just disabled this media. Clear all state. @@ -3108,13 +3194,13 @@ bool LLViewerMediaImpl::isForcedUnloaded() const { return true; } - + // If this media's class is not supposed to be shown, unload if (!shouldShowBasedOnClass()) { return true; } - + return false; } @@ -3127,19 +3213,19 @@ bool LLViewerMediaImpl::isPlayable() const // All of the forced-unloaded criteria also imply not playable. return false; } - + if(hasMedia()) { // Anything that's already playing is, by definition, playable. return true; } - + if(!mMediaURL.empty()) { // If something has navigated the instance, it's ready to be played. return true; } - + return false; } @@ -3151,7 +3237,7 @@ void LLViewerMediaImpl::handleMediaEvent(LLPluginClassMedia* plugin, LLPluginCla { case MEDIA_EVENT_CLICK_LINK_NOFOLLOW: { - LL_DEBUGS("Media") << "MEDIA_EVENT_CLICK_LINK_NOFOLLOW, uri is: " << plugin->getClickURL() << LL_ENDL; + 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); @@ -3170,7 +3256,7 @@ void LLViewerMediaImpl::handleMediaEvent(LLPluginClassMedia* plugin, LLPluginCla // 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); @@ -3192,13 +3278,13 @@ void LLViewerMediaImpl::handleMediaEvent(LLPluginClassMedia* plugin, LLPluginCla //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(); - + if(cursor == "arrow") mLastSetCursor = UI_CURSOR_ARROW; else if(cursor == "ibeam") @@ -3214,6 +3300,13 @@ void LLViewerMediaImpl::handleMediaEvent(LLPluginClassMedia* plugin, LLPluginCla } break; + case LLViewerMediaObserver::MEDIA_EVENT_FILE_DOWNLOAD: + { + //llinfos << "Media event - file download requested - filename is " << self->getFileDownloadFilename() << llendl; + LLNotificationsUtil::add("MediaFileDownloadUnsupported"); + } + break; + case LLViewerMediaObserver::MEDIA_EVENT_NAVIGATE_BEGIN: { LL_DEBUGS("Media") << "MEDIA_EVENT_NAVIGATE_BEGIN, uri is: " << plugin->getNavigateURI() << LL_ENDL; @@ -3259,7 +3352,7 @@ void LLViewerMediaImpl::handleMediaEvent(LLPluginClassMedia* plugin, LLPluginCla } } break; - + case LLViewerMediaObserver::MEDIA_EVENT_LOCATION_CHANGED: { LL_DEBUGS("Media") << "MEDIA_EVENT_LOCATION_CHANGED, uri is: " << plugin->getLocation() << LL_ENDL; @@ -3296,15 +3389,15 @@ void LLViewerMediaImpl::handleMediaEvent(LLPluginClassMedia* plugin, LLPluginCla { // Display a file picker std::string response; - + LLFilePicker& picker = LLFilePicker::instance(); if (!picker.getOpenFile(LLFilePicker::FFLOAD_ALL)) { // The user didn't pick a file -- the empty response string will indicate this. } - + response = picker.getFirstFile(); - + plugin->sendPickFileResponse(response); } break; @@ -3460,7 +3553,7 @@ void LLViewerMediaImpl::calculateInterest() { LL_RECORD_BLOCK_TIME(FTM_MEDIA_CALCULATE_INTEREST); LLViewerMediaTexture* texture = LLViewerTextureManager::findMediaTexture( mTextureId ); - + if(texture != NULL) { mInterest = texture->getMaxVirtualSize(); @@ -3470,7 +3563,7 @@ void LLViewerMediaImpl::calculateInterest() // 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; @@ -3480,7 +3573,7 @@ void LLViewerMediaImpl::calculateInterest() 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()) { @@ -3493,12 +3586,12 @@ void LLViewerMediaImpl::calculateInterest() 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) { @@ -3525,7 +3618,7 @@ void LLViewerMediaImpl::calculateInterest() } } } - + mNeedsMuteCheck = false; } } @@ -3533,7 +3626,7 @@ void LLViewerMediaImpl::calculateInterest() F64 LLViewerMediaImpl::getApproximateTextureInterest() { F64 result = 0.0f; - + if(mMediaSource) { result = mMediaSource->getFullWidth(); @@ -3551,8 +3644,8 @@ F64 LLViewerMediaImpl::getApproximateTextureInterest() void LLViewerMediaImpl::setUsedInUI(bool used_in_ui) { - mUsedInUI = 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)) @@ -3572,7 +3665,7 @@ void LLViewerMediaImpl::setUsedInUI(bool used_in_ui) void LLViewerMediaImpl::setBackgroundColor(LLColor4 color) { - mBackgroundColor = color; + mBackgroundColor = color; if(mMediaSource) { @@ -3583,12 +3676,12 @@ void LLViewerMediaImpl::setBackgroundColor(LLColor4 color) F64 LLViewerMediaImpl::getCPUUsage() const { F64 result = 0.0f; - + if(mMediaSource) { result = mMediaSource->getCPUUsage(); } - + return result; } @@ -3602,19 +3695,19 @@ void LLViewerMediaImpl::setPriority(LLPluginClassMedia::EPriority priority) << " to " << LLPluginClassMedia::priorityToString(priority) << LL_ENDL; } - + mPriority = priority; - + 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(); - + destroyMediaSource(); } } @@ -3623,7 +3716,7 @@ void LLViewerMediaImpl::setPriority(LLPluginClassMedia::EPriority priority) { mMediaSource->setPriority(mPriority); } - + // NOTE: loading (or reloading) media sources whose priority has risen above PRIORITY_UNLOADED is done in update(). } @@ -3638,8 +3731,8 @@ void LLViewerMediaImpl::setLowPrioritySizeLimit(int size) void LLViewerMediaImpl::setNavState(EMediaNavState state) { mMediaNavState = state; - - switch (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; @@ -3678,7 +3771,7 @@ void LLViewerMediaImpl::cancelMimeTypeProbe() // There doesn't seem to be a way to actually cancel an outstanding request. // Simulate it by telling the LLMimeDiscoveryResponder not to write back any results. mMimeTypeProbe->cancelRequest(); - + // The above should already have set mMimeTypeProbe to NULL. if(mMimeTypeProbe != NULL) { @@ -3687,7 +3780,7 @@ void LLViewerMediaImpl::cancelMimeTypeProbe() } } -void LLViewerMediaImpl::addObject(LLVOVolume* obj) +void LLViewerMediaImpl::addObject(LLVOVolume* obj) { std::list< LLVOVolume* >::iterator iter = mObjectList.begin() ; for(; iter != mObjectList.end() ; ++iter) @@ -3701,14 +3794,14 @@ void LLViewerMediaImpl::addObject(LLVOVolume* obj) mObjectList.push_back(obj) ; mNeedsMuteCheck = true; } - -void LLViewerMediaImpl::removeObject(LLVOVolume* obj) + +void LLViewerMediaImpl::removeObject(LLVOVolume* obj) { - mObjectList.remove(obj) ; + mObjectList.remove(obj) ; mNeedsMuteCheck = true; } - -const std::list< LLVOVolume* >* LLViewerMediaImpl::getObjectList() const + +const std::list< LLVOVolume* >* LLViewerMediaImpl::getObjectList() const { return &mObjectList ; } @@ -3716,13 +3809,13 @@ const std::list< LLVOVolume* >* LLViewerMediaImpl::getObjectList() const LLVOVolume *LLViewerMediaImpl::getSomeObject() { LLVOVolume *result = NULL; - + std::list< LLVOVolume* >::iterator iter = mObjectList.begin() ; if(iter != mObjectList.end()) { result = *iter; } - + return result; } @@ -3735,12 +3828,12 @@ void LLViewerMediaImpl::setTextureID(LLUUID id) // Remove this item's entry from the map sViewerMediaTextureIDMap.erase(mTextureId); } - + if(id.notNull()) { sViewerMediaTextureIDMap.insert(LLViewerMedia::impl_id_map::value_type(id, this)); } - + mTextureId = id; } } @@ -3749,7 +3842,7 @@ void LLViewerMediaImpl::setTextureID(LLUUID id) // bool LLViewerMediaImpl::isAutoPlayable() const { - return (mMediaAutoPlay && + return (mMediaAutoPlay && gSavedSettings.getBOOL(LLViewerMedia::AUTO_PLAY_MEDIA_SETTING) && gSavedSettings.getBOOL("MediaTentativeAutoPlay")); } @@ -3760,20 +3853,20 @@ bool LLViewerMediaImpl::shouldShowBasedOnClass() const { // 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(); - + // 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 is attached to an avatar and the pref is off, we shouldn't show it if (attached_to_another_avatar) { @@ -3786,7 +3879,7 @@ bool LLViewerMediaImpl::shouldShowBasedOnClass() const return show_media_within_parcel; } - else + else { static LLCachedControl<bool> show_media_outside_parcel(gSavedSettings, LLViewerMedia::SHOW_MEDIA_OUTSIDE_PARCEL_SETTING, true); @@ -3799,7 +3892,7 @@ bool LLViewerMediaImpl::shouldShowBasedOnClass() const bool LLViewerMediaImpl::isAttachedToAnotherAvatar() const { bool result = false; - + std::list< LLVOVolume* >::const_iterator iter = mObjectList.begin(); std::list< LLVOVolume* >::const_iterator end = mObjectList.end(); for ( ; iter != end; iter++) @@ -3843,7 +3936,7 @@ bool LLViewerMediaImpl::isObjectAttachedToAnotherAvatar(LLVOVolume *obj) bool LLViewerMediaImpl::isInAgentParcel() const { bool result = false; - + std::list< LLVOVolume* >::const_iterator iter = mObjectList.begin(); std::list< LLVOVolume* >::const_iterator end = mObjectList.end(); for ( ; iter != end; iter++) |