Second Life viewer sources 1.19.1.0

1 files changed, 253 insertions, 132 deletions

diff --git a/linden/indra/newview/llwebbrowserctrl.cpp b/linden/indra/newview/llwebbrowserctrl.cpp
index 858c88c..763f73d 100644
--- a/linden/indra/newview/llwebbrowserctrl.cpp
+++ b/linden/indra/newview/llwebbrowserctrl.cpp
@@ -31,7 +31,6 @@
 
 #include "llviewerprecompiledheaders.h"
 
-#if LL_LIBXUL_ENABLED
 
 #include "llwebbrowserctrl.h"
 
@@ -45,6 +44,7 @@
 #include "llviewercontrol.h"
 #include "llviewerwindow.h"
 #include "llweb.h"
+#include "llglimmediate.h"
 
 // linden library includes
 #include "llfocusmgr.h"
@@ -57,44 +57,50 @@ const S32 MAX_TEXTURE_DIMENSION = 2048;
 LLWebBrowserCtrl::LLWebBrowserCtrl( const std::string& name, const LLRect& rect ) :
         LLUICtrl( name, rect, FALSE, NULL, NULL ),
         mTextureDepthBytes( 4 ),
+        mWebBrowserImage( 0 ),
         mEmbeddedBrowserWindowId( 0 ),
         mBorder(NULL),
         mFrequentUpdates( true ),
+        mForceUpdate( false ),
         mOpenLinksInExternalBrowser( false ),
         mOpenLinksInInternalBrowser( false ),
         mOpenAppSLURLs( false ),
         mHomePageUrl( "" ),
         mIgnoreUIScale( true ),
-        mAlwaysRefresh( false )
-{
-        S32 screen_width = mIgnoreUIScale ? llround((F32)mRect.getWidth() * LLUI::sGLScaleFactor.mV[VX]) : llround((F32)mRect.getWidth() * gViewerWindow->getDisplayScale().mV[VX]);
-        S32 screen_height = mIgnoreUIScale ? llround((F32)mRect.getHeight() * LLUI::sGLScaleFactor.mV[VY]) : llround((F32)mRect.getHeight() * gViewerWindow->getDisplayScale().mV[VY]);
-
-        // create a new browser window
-        {
-#if LL_LINUX
-                // Yuck, Mozilla init plays with the locale - push/pop
-                // the locale to protect it, as exotic/non-C locales
-                // causes our code lots of general critical weirdness
-                // and crashness. (SL-35450)
-                std::string saved_locale = setlocale(LC_ALL, NULL);
-#endif // LL_LINUX
-                mEmbeddedBrowserWindowId = LLMozLib::getInstance()->createBrowserWindow( gViewerWindow->getPlatformWindow(), screen_width, screen_height );
-#if LL_LINUX
-                setlocale(LC_ALL, saved_locale.c_str() );
-#endif // LL_LINUX
+        mAlwaysRefresh( false ),
+        mMediaSource( 0 )
+{
+        S32 screen_width = mIgnoreUIScale ? 
+                llround((F32)getRect().getWidth() * LLUI::sGLScaleFactor.mV[VX]) : getRect().getWidth();
+        S32 screen_height = mIgnoreUIScale ? 
+                llround((F32)getRect().getHeight() * LLUI::sGLScaleFactor.mV[VY]) : getRect().getHeight();
+
+
+        LLMediaManager *mgr = LLMediaManager::getInstance();
+
+        if (!mgr)
+        {
+                llwarns << "cannot get media manager" << llendl;
+                return;
+        }
+                
+        mMediaSource = mgr->createSourceFromMimeType("http", "text/html" );
+        if ( !mMediaSource )
+        {
+                llwarns << "media source create failed " << llendl;
+                return;
         }
 
-        // change color to black so transisitons aren't so noticable (this should be in XML eventually)
-        LLMozLib::getInstance()->setBackgroundColor( mEmbeddedBrowserWindowId, 0x00, 0x00, 0x00 );
+        // mMediaSource->init();
+        mMediaSource->addCommand( LLMediaBase::COMMAND_START );
 
         // observe the browser so we can trap HREF events)
-        LLMozLib::getInstance()->addObserver( mEmbeddedBrowserWindowId, this );
+        mMediaSource->addObserver(this);
 
         // create a new texture (based on LLDynamic texture) that will be used to display the output
-        mWebBrowserImage = new LLWebBrowserTexture( screen_width, screen_height, this, mEmbeddedBrowserWindowId );
+        mWebBrowserImage = new LLWebBrowserTexture( screen_width, screen_height, this, mMediaSource );
 
-        LLRect border_rect( 0, mRect.getHeight() + 2, mRect.getWidth() + 2, 0 );
+        LLRect border_rect( 0, getRect().getHeight() + 2, getRect().getWidth() + 2, 0 );
         mBorder = new LLViewBorder( "web control border", border_rect, LLViewBorder::BEVEL_IN );
         addChild( mBorder );
 }
@@ -103,9 +109,19 @@ LLWebBrowserCtrl::LLWebBrowserCtrl( const std::string& name, const LLRect& rect
 // note: this is now a singleton and destruction happens via initClass() now
 LLWebBrowserCtrl::~LLWebBrowserCtrl()
 {
-        LLMozLib::getInstance()->remObserver( mEmbeddedBrowserWindowId, this );
+        LLMediaManager *mgr = LLMediaManager::getInstance();
 
-        LLMozLib::getInstance()->destroyBrowserWindow( mEmbeddedBrowserWindowId );
+        if (!mgr)
+        {
+                llwarns << "cannot get media manager" << llendl;
+                return;
+        }
+
+        if (mMediaSource)
+        {
+                mgr->destroySource(mMediaSource);
+                mMediaSource = NULL;
+        }
 
         if ( mWebBrowserImage )
         {
@@ -163,7 +179,9 @@ void LLWebBrowserCtrl::setOpenAppSLURLs( bool valIn )
 BOOL LLWebBrowserCtrl::handleHover( S32 x, S32 y, MASK mask )
 {
         convertInputCoords(x, y);
-        LLMozLib::getInstance()->mouseMove( mEmbeddedBrowserWindowId, x, y );
+
+        if (mMediaSource)
+                mMediaSource->mouseMove(x, y);
 
         return TRUE;
 }
@@ -172,12 +190,8 @@ BOOL LLWebBrowserCtrl::handleHover( S32 x, S32 y, MASK mask )
 //
 BOOL LLWebBrowserCtrl::handleScrollWheel( S32 x, S32 y, S32 clicks )
 {
-        LLMozLib::getInstance()->scrollByLines( mEmbeddedBrowserWindowId, clicks );
-
-        // note: this isn't really necessary right now since the page is updated
-        // on a timer but if that becomes too burdensome and the page is only updated
-        // once after load then this will be necessary
-        LLMozLib::getInstance()->grabBrowserWindow( mEmbeddedBrowserWindowId );
+        if (mMediaSource)
+                mMediaSource->scrollByLines(clicks);
 
         return TRUE;
 }
@@ -187,8 +201,10 @@ BOOL LLWebBrowserCtrl::handleScrollWheel( S32 x, S32 y, S32 clicks )
 BOOL LLWebBrowserCtrl::handleMouseUp( S32 x, S32 y, MASK mask )
 {
         convertInputCoords(x, y);
-        LLMozLib::getInstance()->mouseUp( mEmbeddedBrowserWindowId, x, y );
 
+        if (mMediaSource)
+                mMediaSource->mouseUp(x, y);
+        
         gViewerWindow->setMouseCapture( NULL );
 
         return TRUE;
@@ -199,8 +215,10 @@ BOOL LLWebBrowserCtrl::handleMouseUp( S32 x, S32 y, MASK mask )
 BOOL LLWebBrowserCtrl::handleMouseDown( S32 x, S32 y, MASK mask )
 {
         convertInputCoords(x, y);
-        LLMozLib::getInstance()->mouseDown( mEmbeddedBrowserWindowId, x, y );
 
+        if (mMediaSource)
+                mMediaSource->mouseDown(x, y);
+        
         gViewerWindow->setMouseCapture( this );
 
         setFocus( TRUE );
@@ -213,7 +231,9 @@ BOOL LLWebBrowserCtrl::handleMouseDown( S32 x, S32 y, MASK mask )
 BOOL LLWebBrowserCtrl::handleDoubleClick( S32 x, S32 y, MASK mask )
 {
         convertInputCoords(x, y);
-        LLMozLib::getInstance()->mouseLeftDoubleClick( mEmbeddedBrowserWindowId, x, y );
+
+        if (mMediaSource)
+                mMediaSource->mouseLeftDoubleClick( x, y );
 
         gViewerWindow->setMouseCapture( this );
 
@@ -226,7 +246,9 @@ BOOL LLWebBrowserCtrl::handleDoubleClick( S32 x, S32 y, MASK mask )
 //
 void LLWebBrowserCtrl::onFocusReceived()
 {
-        LLMozLib::getInstance()->focusBrowser( mEmbeddedBrowserWindowId, true );
+        if (mMediaSource)
+                mMediaSource->focus(true);
+        
 
         LLUICtrl::onFocusReceived();
 }
@@ -235,7 +257,8 @@ void LLWebBrowserCtrl::onFocusReceived()
 //
 void LLWebBrowserCtrl::onFocusLost()
 {
-        LLMozLib::getInstance()->focusBrowser( mEmbeddedBrowserWindowId, false );
+        if (mMediaSource)
+                mMediaSource->focus(false);
 
         gViewerWindow->focusClient();
 
@@ -246,7 +269,7 @@ void LLWebBrowserCtrl::onFocusLost()
 //
 BOOL LLWebBrowserCtrl::handleKey( KEY key, MASK mask, BOOL called_from_parent )
 {
-        unsigned long nskey;
+        unsigned long media_key;
 
         // First, turn SL internal keycode enum into Mozilla keycode enum
 
@@ -254,46 +277,48 @@ BOOL LLWebBrowserCtrl::handleKey( KEY key, MASK mask, BOOL called_from_parent )
         // go through handleUnicodeChar().  This table could be more complete
         // than it is, but I think this covers all of the important
         // non-printables.
+
         switch (key)
         {
         case KEY_BACKSPACE:
-                nskey = LL_DOM_VK_BACK_SPACE; break;
+                media_key = LL_MEDIA_KEY_BACKSPACE; break;
         case KEY_TAB:
-                nskey = LL_DOM_VK_TAB; break;
+                media_key = LL_MEDIA_KEY_TAB; break;
         case KEY_RETURN:
-                nskey = LL_DOM_VK_RETURN; break;
+                media_key = LL_MEDIA_KEY_RETURN; break;
         case KEY_PAD_RETURN:
-                nskey = LL_DOM_VK_ENTER; break;
+                media_key = LL_MEDIA_KEY_PAD_RETURN; break;
         case KEY_ESCAPE:
-                nskey = LL_DOM_VK_ESCAPE; break;
+                media_key = LL_MEDIA_KEY_ESCAPE; break;
         case KEY_PAGE_UP:
-                nskey = LL_DOM_VK_PAGE_UP; break;
+                media_key = LL_MEDIA_KEY_PAGE_UP; break;
         case KEY_PAGE_DOWN:
-                nskey = LL_DOM_VK_PAGE_DOWN; break;
+                media_key = LL_MEDIA_KEY_PAGE_DOWN; break;
         case KEY_END:
-                nskey = LL_DOM_VK_END; break;
+                media_key = LL_MEDIA_KEY_END; break;
         case KEY_HOME:
-                nskey = LL_DOM_VK_HOME; break;
+                media_key = LL_MEDIA_KEY_HOME; break;
         case KEY_LEFT:
-                nskey = LL_DOM_VK_LEFT; break;
+                media_key = LL_MEDIA_KEY_LEFT; break;
         case KEY_UP:
-                nskey = LL_DOM_VK_UP; break;
+                media_key = LL_MEDIA_KEY_UP; break;
         case KEY_RIGHT:
-                nskey = LL_DOM_VK_RIGHT; break;
+                media_key = LL_MEDIA_KEY_RIGHT; break;
         case KEY_DOWN:
-                nskey = LL_DOM_VK_DOWN; break;
+                media_key = LL_MEDIA_KEY_DOWN; break;
         case KEY_INSERT:
-                nskey = LL_DOM_VK_INSERT; break;
+                media_key = LL_MEDIA_KEY_INSERT; break;
         case KEY_DELETE:
-                nskey = LL_DOM_VK_DELETE; break;
+                media_key = LL_MEDIA_KEY_DELETE; break;
         default:
                 llinfos << "Don't know how to map LL keycode " << U32(key)
                         << " to DOM key.  Ignoring." << llendl;
                 return FALSE; // don't know how to map this key.
         }
 
-        LLMozLib::getInstance()->keyPress( mEmbeddedBrowserWindowId, nskey );
-
+        if (mMediaSource)
+                mMediaSource->keyPress(media_key);
+        
         return TRUE;
 }
 
@@ -303,7 +328,8 @@ BOOL LLWebBrowserCtrl::handleUnicodeChar(llwchar uni_char, BOOL called_from_pare
         if (uni_char >= 32 // discard 'control' characters
             && uni_char != 127) // SDL thinks this is 'delete' - yuck.
         {
-                LLMozLib::getInstance()->unicodeInput( mEmbeddedBrowserWindowId, uni_char );
+                if (mMediaSource)
+                        mMediaSource->unicodeInput(uni_char);
         }
 
         return TRUE;
@@ -329,13 +355,14 @@ void LLWebBrowserCtrl::onVisibilityChange ( BOOL new_visibility )
 //
 void LLWebBrowserCtrl::reshape( S32 width, S32 height, BOOL called_from_parent )
 {
-        S32 screen_width = mIgnoreUIScale ? llround((F32)width * LLUI::sGLScaleFactor.mV[VX]) : llround((F32)width * gViewerWindow->getDisplayScale().mV[VX]);
-        S32 screen_height = mIgnoreUIScale ? llround((F32)height * LLUI::sGLScaleFactor.mV[VY]) : llround((F32)height * gViewerWindow->getDisplayScale().mV[VY]);
+        S32 screen_width = mIgnoreUIScale ? llround((F32)width * LLUI::sGLScaleFactor.mV[VX]) : width;
+        S32 screen_height = mIgnoreUIScale ? llround((F32)height * LLUI::sGLScaleFactor.mV[VY]) : height;
 
         // when floater is minimized, these sizes are negative
-        if ( screen_height > 0 && screen_width > 0 )
+        if ( mWebBrowserImage && screen_height > 0 && screen_width > 0 )
         {
                 mWebBrowserImage->resize( screen_width, screen_height );
+                mForceUpdate = true;
         }
 
         LLUICtrl::reshape( width, height, called_from_parent );
@@ -345,42 +372,51 @@ void LLWebBrowserCtrl::reshape( S32 width, S32 height, BOOL called_from_parent )
 //
 void LLWebBrowserCtrl::navigateBack()
 {
-        LLMozLib::getInstance()->navigateBack( mEmbeddedBrowserWindowId );
+        if (mMediaSource)
+                mMediaSource->navigateBack();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 void LLWebBrowserCtrl::navigateForward()
 {
-        LLMozLib::getInstance()->navigateForward( mEmbeddedBrowserWindowId );
+        if (mMediaSource)
+                mMediaSource->navigateForward();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 bool LLWebBrowserCtrl::canNavigateBack()
 {
-        return LLMozLib::getInstance()->canNavigateBack( mEmbeddedBrowserWindowId );
+        if (mMediaSource)
+                return mMediaSource->canNavigateBack();
+        else
+                return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 bool LLWebBrowserCtrl::canNavigateForward()
 {
-        return LLMozLib::getInstance()->canNavigateForward( mEmbeddedBrowserWindowId );
+        if (mMediaSource)
+                return mMediaSource->canNavigateForward();
+        else
+                return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
+
 bool LLWebBrowserCtrl::set404RedirectUrl(  std::string redirect_url )
 {
-        return LLMozLib::getInstance()->set404RedirectUrl( mEmbeddedBrowserWindowId, redirect_url );
+        return mMediaSource->set404RedirectUrl( redirect_url );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 bool LLWebBrowserCtrl::clr404RedirectUrl()
 {
-        return LLMozLib::getInstance()->clr404RedirectUrl( mEmbeddedBrowserWindowId );
+        return mMediaSource->clr404RedirectUrl();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -395,19 +431,22 @@ void LLWebBrowserCtrl::navigateTo( std::string urlIn )
         {
                 if ( LLString::compareInsensitive( urlIn.substr( 0, protocol.length() ).c_str(), protocol.c_str() ) != 0 )
                 {
-                        LLMozLib::getInstance()->navigateTo( mEmbeddedBrowserWindowId, urlIn );
+                if (mMediaSource)
+                        mMediaSource->navigateTo(urlIn);
                 }
         }
         else if ( urlIn.length() >= protocol2.length() )
         {
                 if ( LLString::compareInsensitive( urlIn.substr( 0, protocol2.length() ).c_str(), protocol2.c_str() ) != 0 )
                 {
-                        LLMozLib::getInstance()->navigateTo( mEmbeddedBrowserWindowId, urlIn );
+                if (mMediaSource)
+                        mMediaSource->navigateTo(urlIn);
                 }
         }
         else
         {
-                LLMozLib::getInstance()->navigateTo( mEmbeddedBrowserWindowId, urlIn );
+                if (mMediaSource)
+                        mMediaSource->navigateTo(urlIn);
         }
 }
 
@@ -455,7 +494,8 @@ void LLWebBrowserCtrl::navigateHome()
 {
         if( mHomePageUrl.length() )
         {
-                LLMozLib::getInstance()->navigateTo( mEmbeddedBrowserWindowId, mHomePageUrl );
+                if (mMediaSource)
+                        mMediaSource->navigateTo(mHomePageUrl);
         };
 }
 
@@ -468,6 +508,15 @@ void LLWebBrowserCtrl::setHomePageUrl( const std::string urlIn )
 
 ////////////////////////////////////////////////////////////////////////////////
 //
+bool LLWebBrowserCtrl::setCaretColor(unsigned int red, unsigned int green, unsigned int blue)
+{
+        if (mMediaSource)
+                return mMediaSource->setCaretColor(red, green, blue);
+        else
+                return false;
+}
+////////////////////////////////////////////////////////////////////////////////
+//
 std::string LLWebBrowserCtrl::getHomePageUrl()
 {
         return  mHomePageUrl;
@@ -480,9 +529,12 @@ void LLWebBrowserCtrl::draw()
         if ( ! getVisible() )
                 return;
 
+        if ( ! mWebBrowserImage )
+                return;
+
         // NOTE: optimization needed here - probably only need to do this once
         // unless tearoffs change the parent which they probably do.
-        LLUICtrl* ptr = (LLUICtrl*)findRootMostFocusRoot();
+        const LLUICtrl* ptr = findRootMostFocusRoot();
         if ( ptr && ptr->hasFocus() )
         {
                 setFrequentUpdates( true );
@@ -510,29 +562,29 @@ void LLWebBrowserCtrl::draw()
 
                 // scale texture to fit the space using texture coords
                 mWebBrowserImage->bindTexture();
-                glColor4fv( LLColor4::white.mV );
+                gGL.color4fv( LLColor4::white.mV );
                 F32 max_u = ( F32 )mWebBrowserImage->getBrowserWidth() / ( F32 )mWebBrowserImage->getWidth();
                 F32 max_v = ( F32 )mWebBrowserImage->getBrowserHeight() / ( F32 )mWebBrowserImage->getHeight();
 
                 // draw the browser
-                glBlendFunc( GL_ONE, GL_ZERO );
-                glBegin( GL_QUADS );
+                gGL.blendFunc( GL_ONE, GL_ZERO );
+                gGL.begin( GL_QUADS );
                 {
                         // render using web browser reported width and height, instead of trying to invert GL scale
-                        glTexCoord2f( max_u, 0.f );
-                        glVertex2i( mWebBrowserImage->getBrowserWidth(), mWebBrowserImage->getBrowserHeight() );
+                        gGL.texCoord2f( max_u, max_v );
+                        gGL.vertex2i( mWebBrowserImage->getBrowserWidth(), mWebBrowserImage->getBrowserHeight() );
 
-                        glTexCoord2f( 0.f, 0.f );
-                        glVertex2i( 0, mWebBrowserImage->getBrowserHeight() );
+                        gGL.texCoord2f( 0.f, max_v );
+                        gGL.vertex2i( 0, mWebBrowserImage->getBrowserHeight() );
 
-                        glTexCoord2f( 0.f, max_v );
-                        glVertex2i( 0, 0 );
+                        gGL.texCoord2f( 0.f, 0.f );
+                        gGL.vertex2i( 0, 0 );
 
-                        glTexCoord2f( max_u, max_v );
-                        glVertex2i( mWebBrowserImage->getBrowserWidth(), 0 );
+                        gGL.texCoord2f( max_u, 0.f );
+                        gGL.vertex2i( mWebBrowserImage->getBrowserWidth(), 0 );
                 }
-                glEnd();
-                glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA  );
+                gGL.end();
+                gGL.blendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA  );
         }
         glPopMatrix();
 
@@ -546,15 +598,15 @@ void LLWebBrowserCtrl::draw()
 
 void LLWebBrowserCtrl::convertInputCoords(S32& x, S32& y)
 {
-        x = mIgnoreUIScale ? llround((F32)x * LLUI::sGLScaleFactor.mV[VX]) : llround((F32)x * gViewerWindow->getDisplayScale().mV[VX]);
-        y = mIgnoreUIScale ? llround((F32)(mRect.getHeight() - y) * LLUI::sGLScaleFactor.mV[VY]) : llround((F32)(mRect.getHeight() - y) * gViewerWindow->getDisplayScale().mV[VY]);
+        x = mIgnoreUIScale ? llround((F32)x * LLUI::sGLScaleFactor.mV[VX]) : x;
+        y = mIgnoreUIScale ? llround((F32)(getRect().getHeight() - y) * LLUI::sGLScaleFactor.mV[VY]) : getRect().getHeight() - y;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // virtual
 void LLWebBrowserCtrl::onNavigateBegin( const EventType& eventIn )
 {
-        LLWebBrowserCtrlEvent event;
+        LLWebBrowserCtrlEvent event( eventIn.getStringValue() );
         mEventEmitter.update( &LLWebBrowserCtrlObserver::onNavigateBegin, event );
 }
 
@@ -563,7 +615,7 @@ void LLWebBrowserCtrl::onNavigateBegin( const EventType& eventIn )
 void LLWebBrowserCtrl::onNavigateComplete( const EventType& eventIn )
 {
         // chain this event on to observers of an instance of LLWebBrowserCtrl
-        LLWebBrowserCtrlEvent event;
+        LLWebBrowserCtrlEvent event( eventIn.getStringValue() );
         mEventEmitter.update( &LLWebBrowserCtrlObserver::onNavigateComplete, event );
 }
 
@@ -606,16 +658,29 @@ void LLWebBrowserCtrl::onLocationChange( const EventType& eventIn )
 
 ////////////////////////////////////////////////////////////////////////////////
 // virtual
+void LLWebBrowserCtrl::onMediaContentsChange( const EventType& event_in )
+{
+        if ( mWebBrowserImage )
+        {
+                mWebBrowserImage->setNeedsUpdate();
+                mForceUpdate = true;
+        }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// virtual
 void LLWebBrowserCtrl::onClickLinkHref( const EventType& eventIn )
 {
-        const std::string protocol( "http://" );
+        const std::string protocol1( "http://" );
+        const std::string protocol2( "https://" );
         if( mOpenLinksInExternalBrowser )
         {
                 if ( eventIn.getStringValue().length() )
                 {
-                        if ( LLString::compareInsensitive( eventIn.getStringValue().substr( 0, protocol.length() ).c_str(), protocol.c_str() ) == 0 )
+                        if ( LLString::compareInsensitive( eventIn.getStringValue().substr( 0, protocol1.length() ).c_str(), protocol1.c_str() ) == 0 ||
+                                 LLString::compareInsensitive( eventIn.getStringValue().substr( 0, protocol2.length() ).c_str(), protocol2.c_str() ) == 0 )
                         {
-                                LLWeb::loadURL( eventIn.getStringValue() );
+                                LLWeb::loadURLExternal( eventIn.getStringValue() );
                         };
                 };
         }
@@ -624,15 +689,14 @@ void LLWebBrowserCtrl::onClickLinkHref( const EventType& eventIn )
         {
                 if ( eventIn.getStringValue().length() )
                 {
-                        if ( LLString::compareInsensitive( eventIn.getStringValue().substr( 0, protocol.length() ).c_str(), protocol.c_str() ) == 0 )
+                        if ( LLString::compareInsensitive( eventIn.getStringValue().substr( 0, protocol1.length() ).c_str(), protocol1.c_str() ) == 0 ||
+                                 LLString::compareInsensitive( eventIn.getStringValue().substr( 0, protocol2.length() ).c_str(), protocol2.c_str() ) == 0 )
                         {
                                 // If we spawn a new LLFloaterHTML, assume we want it to
                                 // follow this LLWebBrowserCtrl's setting for whether or
                                 // not to open secondlife:///app/ links. JC.
-                                LLFloaterHtml::getInstance()->show( 
-                                        eventIn.getStringValue(), 
-                                                "Second Life Browser",
-                                                        mOpenAppSLURLs);
+                                bool open_links_externally = false;
+                                LLFloaterHtml::getInstance()->show( eventIn.getStringValue(), "Second Life Browser", mOpenAppSLURLs, open_links_externally);
                         };
                 };
         };
@@ -644,7 +708,7 @@ void LLWebBrowserCtrl::onClickLinkHref( const EventType& eventIn )
 
 ////////////////////////////////////////////////////////////////////////////////
 // virtual
-void LLWebBrowserCtrl::onClickLinkSecondLife( const EventType& eventIn )
+void LLWebBrowserCtrl::onClickLinkNoFollow( const EventType& eventIn )
 {
         std::string url = eventIn.getStringValue();
         if (LLURLDispatcher::isSLURLCommand(url)
@@ -659,17 +723,18 @@ void LLWebBrowserCtrl::onClickLinkSecondLife( const EventType& eventIn )
 
         // chain this event on to observers of an instance of LLWebBrowserCtrl
         LLWebBrowserCtrlEvent event( eventIn.getStringValue() );
-        mEventEmitter.update( &LLWebBrowserCtrlObserver::onClickLinkSecondLife, event );
+        mEventEmitter.update( &LLWebBrowserCtrlObserver::onClickLinkNoFollow, event );
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 //
-LLWebBrowserTexture::LLWebBrowserTexture( S32 width, S32 height, LLWebBrowserCtrl* browserCtrl, int browserWindowId ) :
+LLWebBrowserTexture::LLWebBrowserTexture( S32 width, S32 height, LLWebBrowserCtrl* browserCtrl, LLMediaBase *media_source ) :
         LLDynamicTexture( 512, 512, 4, ORDER_FIRST, TRUE ),
         mLastBrowserDepth( 0 ),
+        mNeedsUpdate( true ),
         mWebBrowserCtrl( browserCtrl ),
-        mEmbeddedBrowserWindowId( browserWindowId )
+        mMediaSource(media_source)
 {
         mElapsedTime.start();
 
@@ -685,35 +750,71 @@ LLWebBrowserTexture::~LLWebBrowserTexture()
 
 ////////////////////////////////////////////////////////////////////////////////
 //
-BOOL LLWebBrowserTexture::render()
+BOOL LLWebBrowserTexture::needsRender()
 {
-        // frequent updates turned on?
-        if ( mWebBrowserCtrl->getFrequentUpdates() || mWebBrowserCtrl->getAlwaysRefresh() )
+        if ( mWebBrowserCtrl->getFrequentUpdates() || 
+                mWebBrowserCtrl->getAlwaysRefresh() ||
+                mWebBrowserCtrl->getForceUpdate() )
         {
                 // only update mozilla/texture occasionally
                 if ( mElapsedTime.getElapsedTimeF32() > ( 1.0f / 15.0f ) )
                 {
-                        mElapsedTime.reset();
+                        return TRUE;
+                }
+        }
+
+        return FALSE;
+}
 
-                        const unsigned char* pixels = LLMozLib::getInstance()->grabBrowserWindow( mEmbeddedBrowserWindowId );
+////////////////////////////////////////////////////////////////////////////////
+//
+BOOL LLWebBrowserTexture::render()
+{
+        if (!mMediaSource)
+                return FALSE;
+        
+        // frequent updates turned on?
+        if ( mWebBrowserCtrl->getFrequentUpdates() || 
+                mWebBrowserCtrl->getAlwaysRefresh() ||
+                mWebBrowserCtrl->getForceUpdate() )
+        {
 
-                        S32 actual_rowspan = LLMozLib::getInstance()->getBrowserRowSpan( mEmbeddedBrowserWindowId );
-                        S32 browser_depth = LLMozLib::getInstance()->getBrowserDepth( mEmbeddedBrowserWindowId );
+                if ( mNeedsUpdate )
+                {
 
+                        const unsigned char* pixels = mMediaSource->getMediaData();
+                        if ( ! pixels )
+                                return FALSE;
+                        
+                        mNeedsUpdate = false;
+                        mWebBrowserCtrl->setForceUpdate(false);
+
+                        S32 media_depth  = mMediaSource->getMediaDepth();
+                        S32 media_width  = mMediaSource->getMediaWidth();
+                        S32 media_height = mMediaSource->getMediaHeight();
+                        
                         // these are both invalid conditions and should never happen but SL-27583 indicates it does
-                        if ( actual_rowspan < 1 || browser_depth < 2 )
+                        if ((media_width < 1) || (media_depth < 2))
                                 return FALSE;
 
-                        // width can change after it's rendered - (Mozilla bug# 24721)
-                        S32 pagebuffer_width = actual_rowspan / browser_depth;
-
                         // Browser depth hasn't changed.  
-                        if(mLastBrowserDepth == browser_depth)
+                        if(mLastBrowserDepth == media_depth)
                         {
+                                S32 width  = llmin(media_width, mBrowserWidth);
+                                S32 height = llmin(media_height, mBrowserHeight);
+
+                                S32 media_data_width  = mMediaSource->getMediaDataWidth();
+                                S32 media_data_height = mMediaSource->getMediaDataHeight();
+
                                 // Just grab the pixels.
-                                mTexture->setSubImage( pixels,
-                                                                                pagebuffer_width, mBrowserHeight,
-                                                                                        0, 0, pagebuffer_width, mBrowserHeight );
+                                if ( media_data_width > 0 && media_data_height > 0 &&
+                                                media_data_width < MAX_DIMENSION && media_data_height < MAX_DIMENSION )
+                                {
+                                        mTexture->setSubImage( pixels, 
+                                                                                        media_data_width, media_data_height,
+                                                                                                0, 0, 
+                                                                                                        width, height );
+                                };
                         }
                         else
                         {
@@ -740,11 +841,20 @@ S32 LLWebBrowserTexture::getBrowserHeight()
         return mBrowserHeight;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+//
+void LLWebBrowserTexture::setNeedsUpdate()
+{
+        mNeedsUpdate = true;
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 void LLWebBrowserTexture::resize( S32 new_width, S32 new_height )
 {
+        if (!mMediaSource)
+                return;
+        
         F32 scale_ratio = 1.f;
         if (new_width > MAX_DIMENSION)
         {
@@ -758,23 +868,25 @@ void LLWebBrowserTexture::resize( S32 new_width, S32 new_height )
         mBrowserWidth = llround(scale_ratio * (F32)new_width);
         mBrowserHeight = llround(scale_ratio * (F32)new_height);
 
-        LLMozLib::getInstance()->setSize( mEmbeddedBrowserWindowId, mBrowserWidth, mBrowserHeight );
+        mMediaSource->setRequestedMediaSize(mBrowserWidth, mBrowserHeight);
 
-        const unsigned char* pixels = LLMozLib::getInstance()->grabBrowserWindow( mEmbeddedBrowserWindowId );
+        // HACK - this code is executing a render - resize should call render() instead
+        // (and render() should be refactored so it doesn't call resize())
+        
+        const unsigned char* pixels = mMediaSource->getMediaData();
 
-        S32 actual_rowspan = LLMozLib::getInstance()->getBrowserRowSpan( mEmbeddedBrowserWindowId );
-        S32 browser_depth = LLMozLib::getInstance()->getBrowserDepth( mEmbeddedBrowserWindowId );
+        S32 media_width  = mMediaSource->getMediaWidth();
+        S32 media_height = mMediaSource->getMediaHeight();
+        S32 media_depth  = mMediaSource->getMediaDepth();
 
         // these are both invalid conditions and should never happen but SL-27583 indicates it does
-        if ( actual_rowspan < 1 || browser_depth < 2 )
+        if ( media_width < 1 || media_depth < 2 )
                 return;
-
-        releaseGLTexture();
         
-        S32 pagebuffer_width = actual_rowspan / browser_depth;
+        releaseGLTexture();
 
         // calculate the next power of 2 bigger than reqquested size for width and height
-        for ( mWidth = 1; mWidth < pagebuffer_width; mWidth <<= 1 )
+        for ( mWidth = 1; mWidth < mBrowserWidth; mWidth <<= 1 )
         {
                 if ( mWidth >= MAX_TEXTURE_DIMENSION )
                 {
@@ -795,7 +907,7 @@ void LLWebBrowserTexture::resize( S32 new_width, S32 new_height )
         LLGLenum type_format;
         BOOL     swap_bytes = FALSE;
 
-        switch(browser_depth)
+        switch(media_depth)
         {
                 default:
                 case 4:
@@ -831,12 +943,21 @@ void LLWebBrowserTexture::resize( S32 new_width, S32 new_height )
         
         // will create mWidth * mHeight sized texture, using BGR ordering
         LLDynamicTexture::generateGLTexture(internal_format, primary_format, type_format, swap_bytes);
+
+
+        S32 width  = llmin(media_width, mBrowserWidth);
+        S32 height = llmin(media_height, mBrowserHeight);
+
+        S32 media_data_width  = mMediaSource->getMediaDataWidth();
+        S32 media_data_height = mMediaSource->getMediaDataHeight();
+
+        if (pixels)
+        {
+                mTexture->setSubImage( pixels, media_data_width, media_data_height,
+                                                           0, 0, width, height );
+        }
         
-        mTexture->setSubImage( pixels,
-                pagebuffer_width, mBrowserHeight,
-                        0, 0, pagebuffer_width, mBrowserHeight );
-        
-        mLastBrowserDepth = browser_depth;
+        mLastBrowserDepth = media_depth;
 }
 
 LLView* LLWebBrowserCtrl::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
@@ -860,7 +981,7 @@ LLView* LLWebBrowserCtrl::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFac
                 LLColor4 color;
                 LLUICtrlFactory::getAttributeColor(node, "caret_color", color);
                 LLColor4U colorU = LLColor4U(color);
-                LLMozLib::getInstance()->setCaretColor( web_browser->mEmbeddedBrowserWindowId,  colorU.mV[0], colorU.mV[1], colorU.mV[2] );
+                web_browser->setCaretColor( colorU.mV[0], colorU.mV[1], colorU.mV[2] );
         }
 
         BOOL ignore_ui_scale = web_browser->getIgnoreUIScale();
@@ -878,4 +999,4 @@ LLView* LLWebBrowserCtrl::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFac
         return web_browser;
 }
 
-#endif // LL_LIBXUL_ENABLED
+