Merged Experimental branch (exp) back into main line (next).

Git thought many files (almost 100) had merge conflicts. But, after
resolving the conflicts (which were mostly trivial), almost all the
files turned out to be the same as in the exp branch. So, the
conflicts are not listed here. Check the diff between commit 244ffe8
and this commit to see what really changed.

24 files changed, 7380 insertions, 0 deletions

diff --git a/linden/indra/llplugin/CMakeLists.txt b/linden/indra/llplugin/CMakeLists.txt
new file mode 100644
index 0000000..5dbe07c
--- /dev/null
+++ b/linden/indra/llplugin/CMakeLists.txt
@@ -0,0 +1,82 @@
+# -*- cmake -*-
+
+project(llplugin)
+
+include(00-Common)
+include(CURL)
+include(LLCommon)
+include(LLImage)
+include(LLMath)
+include(LLMessage)
+include(LLRender)
+include(LLXML)
+include(LLWindow)
+
+include_directories(
+    ${LLCOMMON_INCLUDE_DIRS}
+    ${LLIMAGE_INCLUDE_DIRS}
+    ${LLMATH_INCLUDE_DIRS}
+    ${LLMESSAGE_INCLUDE_DIRS}
+    ${LLRENDER_INCLUDE_DIRS}
+    ${LLXML_INCLUDE_DIRS}
+    ${LLWINDOW_INCLUDE_DIRS}
+    )
+
+set(llplugin_SOURCE_FILES
+    llpluginclassmedia.cpp
+    llplugincookiestore.cpp
+    llplugininstance.cpp
+    llpluginmessage.cpp
+    llpluginmessagepipe.cpp
+    llpluginprocesschild.cpp
+    llpluginprocessparent.cpp
+    llpluginsharedmemory.cpp
+    )
+
+set(llplugin_HEADER_FILES
+    CMakeLists.txt
+
+    llpluginclassmedia.h
+    llpluginclassmediaowner.h
+    llplugincookiestore.h
+    llplugininstance.h
+    llpluginmessage.h
+    llpluginmessageclasses.h
+    llpluginmessagepipe.h
+    llpluginprocesschild.h
+    llpluginprocessparent.h
+    llpluginsharedmemory.h
+    )
+
+set_source_files_properties(${llplugin_HEADER_FILES}
+                            PROPERTIES HEADER_FILE_ONLY TRUE)
+
+if(NOT CMAKE_SIZEOF_VOID_P MATCHES 4)
+        if(WINDOWS)
+                add_definitions(/FIXED:NO)
+        else(WINDOWS) # not windows therefore gcc LINUX and DARWIN
+                add_definitions(-fPIC)
+        endif(WINDOWS)
+endif (NOT CMAKE_SIZEOF_VOID_P MATCHES 4)
+
+list(APPEND llplugin_SOURCE_FILES ${llplugin_HEADER_FILES})
+
+add_library (llplugin ${llplugin_SOURCE_FILES})
+
+add_subdirectory(slplugin)
+
+# # Add tests
+# include(LLAddBuildTest)
+# # UNIT TESTS
+# SET(llplugin_TEST_SOURCE_FILES
+#   llplugincookiestore.cpp
+#   )
+# 
+# # llplugincookiestore has a dependency on curl, so we need to link the curl library into the test.
+# set_source_files_properties(
+#   llplugincookiestore.cpp
+#   PROPERTIES
+#     LL_TEST_ADDITIONAL_LIBRARIES "${CURL_LIBRARIES}"
+#   )
+# 
+# LL_ADD_PROJECT_UNIT_TESTS(llplugin "${llplugin_TEST_SOURCE_FILES}")
diff --git a/linden/indra/llplugin/llpluginclassmedia.cpp b/linden/indra/llplugin/llpluginclassmedia.cpp
new file mode 100755
index 0000000..f0a44f7
--- /dev/null
+++ b/linden/indra/llplugin/llpluginclassmedia.cpp
@@ -0,0 +1,1236 @@
+/** 
+ * @file llpluginclassmedia.cpp
+ * @brief LLPluginClassMedia handles a plugin which knows about the "media" message class.
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+/// IMPRUDENCE: this is part of the viewer
+
+#include "linden_common.h"
+#include "indra_constants.h"
+
+#include "llpluginclassmedia.h"
+#include "llpluginmessageclasses.h"
+
+static int LOW_PRIORITY_TEXTURE_SIZE_DEFAULT = 256;
+
+static int nextPowerOf2( int value )
+{
+        int next_power_of_2 = 1;
+        while ( next_power_of_2 < value )
+        {
+                next_power_of_2 <<= 1;
+        }
+        
+        return next_power_of_2;
+}
+
+LLPluginClassMedia::LLPluginClassMedia(LLPluginClassMediaOwner *owner)
+{
+        mOwner = owner;
+        mPlugin = NULL;
+        reset();
+
+        //debug use
+        mDeleteOK = true ;
+}
+
+
+LLPluginClassMedia::~LLPluginClassMedia()
+{
+        llassert_always(mDeleteOK) ;
+        reset();
+}
+
+bool LLPluginClassMedia::init(const std::string &launcher_filename, const std::string &plugin_filename, bool debug)
+{
+        LL_DEBUGS("PluginClassMedia") << "launcher: " << launcher_filename << LL_ENDL;
+        LL_DEBUGS("PluginClassMedia") << "plugin: " << plugin_filename << LL_ENDL;
+
+        mPlugin = new LLPluginProcessParent(this);
+        mPlugin->setSleepTime(mSleepTime);
+        
+        // Queue up the media init message -- it will be sent after all the currently queued messages.
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "init");
+        sendMessage(message);
+        
+        mPlugin->init(launcher_filename, plugin_filename, debug);
+
+        return true;
+}
+
+
+void LLPluginClassMedia::reset()
+{
+        if(mPlugin != NULL)
+        {
+                delete mPlugin;
+                mPlugin = NULL;
+        }
+
+        mTextureParamsReceived = false;
+        mRequestedTextureDepth = 0;
+        mRequestedTextureInternalFormat = 0;
+        mRequestedTextureFormat = 0;
+        mRequestedTextureType = 0;
+        mRequestedTextureSwapBytes = false;
+        mRequestedTextureCoordsOpenGL = false;
+        mTextureSharedMemorySize = 0;
+        mTextureSharedMemoryName.clear();
+        mDefaultMediaWidth = 0;
+        mDefaultMediaHeight = 0;
+        mNaturalMediaWidth = 0;
+        mNaturalMediaHeight = 0;
+        mSetMediaWidth = -1;
+        mSetMediaHeight = -1;
+        mRequestedMediaWidth = 0;
+        mRequestedMediaHeight = 0;
+        mRequestedTextureWidth = 0;
+        mRequestedTextureHeight = 0;
+        mFullMediaWidth = 0;
+        mFullMediaHeight = 0;
+        mTextureWidth = 0;
+        mTextureHeight = 0;
+        mMediaWidth = 0;
+        mMediaHeight = 0;
+        mDirtyRect = LLRect::null;      
+        mAutoScaleMedia = false;
+        mRequestedVolume = 1.0f;
+        mPriority = PRIORITY_NORMAL;
+        mLowPrioritySizeLimit = LOW_PRIORITY_TEXTURE_SIZE_DEFAULT;
+        mAllowDownsample = false;
+        mPadding = 0;
+        mLastMouseX = 0;
+        mLastMouseY = 0;
+        mStatus = LLPluginClassMediaOwner::MEDIA_NONE;
+        mSleepTime = 1.0f / 100.0f;
+        mCanCut = false;
+        mCanCopy = false;
+        mCanPaste = false;
+        mMediaName.clear();
+        mMediaDescription.clear();
+        mBackgroundColor = LLColor4(1.0f, 1.0f, 1.0f, 1.0f);
+        
+        // media_browser class
+        mNavigateURI.clear();
+        mNavigateResultCode = -1;
+        mNavigateResultString.clear();
+        mHistoryBackAvailable = false;
+        mHistoryForwardAvailable = false;
+        mStatusText.clear();
+        mProgressPercent = 0;   
+        mClickURL.clear();
+        mClickTarget.clear();
+        
+        // media_time class
+        mCurrentTime = 0.0f;
+        mDuration = 0.0f;
+        mCurrentRate = 0.0f;
+        mLoadedDuration = 0.0f;
+}
+
+void LLPluginClassMedia::idle(void)
+{
+        if(mPlugin)
+        {
+                mPlugin->idle();
+        }
+        
+        if((mMediaWidth == -1) || (!mTextureParamsReceived) || (mPlugin == NULL) || (mPlugin->isBlocked()))
+        {
+                // Can't process a size change at this time
+        }
+        else if((mRequestedMediaWidth != mMediaWidth) || (mRequestedMediaHeight != mMediaHeight))
+        {
+                // Calculate the correct size for the media texture
+                mRequestedTextureHeight = mRequestedMediaHeight;
+                if(mPadding < 0)
+                {
+                        // negative values indicate the plugin wants a power of 2
+                        mRequestedTextureWidth = nextPowerOf2(mRequestedMediaWidth);
+                }
+                else
+                {
+                        mRequestedTextureWidth = mRequestedMediaWidth;
+                        
+                        if(mPadding > 1)
+                        {
+                                // Pad up to a multiple of the specified number of bytes per row
+                                int rowbytes = mRequestedTextureWidth * mRequestedTextureDepth;
+                                int pad = rowbytes % mPadding;
+                                if(pad != 0)
+                                {
+                                        rowbytes += mPadding - pad;
+                                }
+                                
+                                if(rowbytes % mRequestedTextureDepth == 0)
+                                {
+                                        mRequestedTextureWidth = rowbytes / mRequestedTextureDepth;
+                                }
+                                else
+                                {
+                                        LL_WARNS("PluginClassMedia") << "Unable to pad texture width, padding size " << mPadding << "is not a multiple of pixel size " << mRequestedTextureDepth << LL_ENDL;
+                                }
+                        }
+                }
+
+                
+                // Size change has been requested but not initiated yet.
+                size_t newsize = mRequestedTextureWidth * mRequestedTextureHeight * mRequestedTextureDepth;
+
+                // Add an extra line for padding, just in case.
+                newsize += mRequestedTextureWidth * mRequestedTextureDepth;
+
+                if(newsize != mTextureSharedMemorySize)
+                {
+                        if(!mTextureSharedMemoryName.empty())
+                        {
+                                // Tell the plugin to remove the old memory segment
+                                mPlugin->removeSharedMemory(mTextureSharedMemoryName);
+                                mTextureSharedMemoryName.clear();
+                        }
+                        
+                        mTextureSharedMemorySize = newsize;
+                        mTextureSharedMemoryName = mPlugin->addSharedMemory(mTextureSharedMemorySize);
+                        if(!mTextureSharedMemoryName.empty())
+                        {
+                                void *addr = mPlugin->getSharedMemoryAddress(mTextureSharedMemoryName);
+                                
+                                // clear texture memory to avoid random screen visual fuzz from uninitialized texture data
+                                memset( addr, 0x00, newsize );
+                                
+                                // We could do this to force an update, but textureValid() will still be returning false until the first roundtrip to the plugin,
+                                // so it may not be worthwhile.
+                                // mDirtyRect.setOriginAndSize(0, 0, mRequestedMediaWidth, mRequestedMediaHeight);
+                        }
+                }
+                
+                // This is our local indicator that a change is in progress.
+                mTextureWidth = -1;
+                mTextureHeight = -1;
+                mMediaWidth = -1;
+                mMediaHeight = -1;
+
+                // This invalidates any existing dirty rect.
+                resetDirty();
+                
+                // Send a size change message to the plugin
+                {
+                        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "size_change");
+                        message.setValue("name", mTextureSharedMemoryName);
+                        message.setValueS32("width", mRequestedMediaWidth);
+                        message.setValueS32("height", mRequestedMediaHeight);
+                        message.setValueS32("texture_width", mRequestedTextureWidth);
+                        message.setValueS32("texture_height", mRequestedTextureHeight);
+                        message.setValueReal("background_r", mBackgroundColor.mV[VX]);
+                        message.setValueReal("background_g", mBackgroundColor.mV[VY]);
+                        message.setValueReal("background_b", mBackgroundColor.mV[VZ]);
+                        message.setValueReal("background_a", mBackgroundColor.mV[VW]);
+                        mPlugin->sendMessage(message);  // DO NOT just use sendMessage() here -- we want this to jump ahead of the queue.
+
+                        LL_DEBUGS("PluginClassMedia") << "Sending size_change" << LL_ENDL;
+                }
+        }
+
+        if(mPlugin && mPlugin->isRunning())
+        {
+                // Send queued messages
+                while(!mSendQueue.empty())
+                {
+                        LLPluginMessage message = mSendQueue.front();
+                        mSendQueue.pop();
+                        mPlugin->sendMessage(message);
+                }
+        }
+}
+
+int LLPluginClassMedia::getTextureWidth() const
+{
+        return nextPowerOf2(mTextureWidth);
+}
+
+int LLPluginClassMedia::getTextureHeight() const
+{
+        return nextPowerOf2(mTextureHeight);
+}
+
+unsigned char* LLPluginClassMedia::getBitsData()
+{
+        unsigned char *result = NULL;
+        if((mPlugin != NULL) && !mTextureSharedMemoryName.empty())
+        {
+                result = (unsigned char*)mPlugin->getSharedMemoryAddress(mTextureSharedMemoryName);
+        }
+        return result;
+}
+
+void LLPluginClassMedia::setSize(int width, int height)
+{
+        if((width > 0) && (height > 0))
+        {
+                mSetMediaWidth = width;
+                mSetMediaHeight = height;
+        }
+        else
+        {
+                mSetMediaWidth = -1;
+                mSetMediaHeight = -1;
+        }
+
+        setSizeInternal();
+}
+
+void LLPluginClassMedia::setSizeInternal(void)
+{
+        if((mSetMediaWidth > 0) && (mSetMediaHeight > 0))
+        {
+                mRequestedMediaWidth = mSetMediaWidth;
+                mRequestedMediaHeight = mSetMediaHeight;
+        }
+        else if((mNaturalMediaWidth > 0) && (mNaturalMediaHeight > 0))
+        {
+                mRequestedMediaWidth = mNaturalMediaWidth;
+                mRequestedMediaHeight = mNaturalMediaHeight;
+        }
+        else
+        {
+                mRequestedMediaWidth = mDefaultMediaWidth;
+                mRequestedMediaHeight = mDefaultMediaHeight;
+        }
+        
+        // Save these for size/interest calculations
+        mFullMediaWidth = mRequestedMediaWidth;
+        mFullMediaHeight = mRequestedMediaHeight;
+        
+        if(mAllowDownsample)
+        {
+                switch(mPriority)
+                {
+                        case PRIORITY_SLIDESHOW:
+                        case PRIORITY_LOW:
+                                // Reduce maximum texture dimension to (or below) mLowPrioritySizeLimit
+                                while((mRequestedMediaWidth > mLowPrioritySizeLimit) || (mRequestedMediaHeight > mLowPrioritySizeLimit))
+                                {
+                                        mRequestedMediaWidth /= 2;
+                                        mRequestedMediaHeight /= 2;
+                                }
+                        break;
+                        
+                        default:
+                                // Don't adjust texture size
+                        break;
+                }
+        }
+        
+        if(mAutoScaleMedia)
+        {
+                mRequestedMediaWidth = nextPowerOf2(mRequestedMediaWidth);
+                mRequestedMediaHeight = nextPowerOf2(mRequestedMediaHeight);
+        }
+        
+        if(mRequestedMediaWidth > 2048)
+                mRequestedMediaWidth = 2048;
+
+        if(mRequestedMediaHeight > 2048)
+                mRequestedMediaHeight = 2048;
+}
+
+void LLPluginClassMedia::setAutoScale(bool auto_scale)
+{
+        if(auto_scale != mAutoScaleMedia)
+        {
+                mAutoScaleMedia = auto_scale;
+                setSizeInternal();
+        }
+}
+
+bool LLPluginClassMedia::textureValid(void)
+{
+        if(
+                !mTextureParamsReceived ||
+                mTextureWidth <= 0 ||
+                mTextureHeight <= 0 ||
+                mMediaWidth <= 0 ||
+                mMediaHeight <= 0 ||
+                mRequestedMediaWidth != mMediaWidth ||
+                mRequestedMediaHeight != mMediaHeight ||
+                getBitsData() == NULL
+        )       
+                return false;
+        
+        return true;
+}
+
+bool LLPluginClassMedia::getDirty(LLRect *dirty_rect)
+{
+        bool result = !mDirtyRect.isEmpty();
+
+        if(dirty_rect != NULL)
+        {
+                *dirty_rect = mDirtyRect;
+        }
+
+        return result;
+}
+
+void LLPluginClassMedia::resetDirty(void)
+{
+        mDirtyRect = LLRect::null;
+}
+
+std::string LLPluginClassMedia::translateModifiers(MASK modifiers)
+{
+        std::string result;
+        
+        
+        if(modifiers & MASK_CONTROL)
+        {
+                result += "control|";
+        }
+
+        if(modifiers & MASK_ALT)
+        {
+                result += "alt|";
+        }
+
+        if(modifiers & MASK_SHIFT)
+        {
+                result += "shift|";
+        }
+
+        // TODO: should I deal with platform differences here or in callers?
+        // TODO: how do we deal with the Mac "command" key?
+/*
+        if(modifiers & MASK_SOMETHING)
+        {
+                result += "meta|";
+        }
+*/      
+        return result;
+}
+
+void LLPluginClassMedia::mouseEvent(EMouseEventType type, int button, int x, int y, MASK modifiers)
+{
+        if(type == MOUSE_EVENT_MOVE)
+        {
+                if(!mPlugin || !mPlugin->isRunning() || mPlugin->isBlocked())
+                {
+                        // Don't queue up mouse move events that can't be delivered.
+                        return;
+                }
+
+                if((x == mLastMouseX) && (y == mLastMouseY))
+                {
+                        // Don't spam unnecessary mouse move events.
+                        return;
+                }
+                
+                mLastMouseX = x;
+                mLastMouseY = y;
+        }
+        
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "mouse_event");
+        std::string temp;
+        switch(type)
+        {
+                case MOUSE_EVENT_DOWN:                  temp = "down";                  break;
+                case MOUSE_EVENT_UP:                    temp = "up";                    break;
+                case MOUSE_EVENT_MOVE:                  temp = "move";                  break;
+                case MOUSE_EVENT_DOUBLE_CLICK:  temp = "double_click";  break;
+        }
+        message.setValue("event", temp);
+
+        message.setValueS32("button", button);
+
+        message.setValueS32("x", x);
+        
+        // Incoming coordinates are OpenGL-style ((0,0) = lower left), so flip them here if the plugin has requested it.
+        if(!mRequestedTextureCoordsOpenGL)
+        {
+                // TODO: Should I use mMediaHeight or mRequestedMediaHeight here?
+                y = mMediaHeight - y;
+        }
+        message.setValueS32("y", y);
+
+        message.setValue("modifiers", translateModifiers(modifiers));
+        
+        sendMessage(message);
+}
+
+bool LLPluginClassMedia::keyEvent(EKeyEventType type, int key_code, MASK modifiers, LLSD native_key_data)
+{
+        bool result = true;
+        
+        // FIXME:
+        // HACK: we don't have an easy way to tell if the plugin is going to handle a particular keycode.
+        // For now, return false for the ones the webkit plugin won't handle properly.
+        
+        switch(key_code)
+        {
+                case KEY_BACKSPACE:             
+                case KEY_TAB:                   
+                case KEY_RETURN:                
+                case KEY_PAD_RETURN:    
+                case KEY_SHIFT:                 
+                case KEY_CONTROL:               
+                case KEY_ALT:                   
+                case KEY_CAPSLOCK:              
+                case KEY_ESCAPE:                
+                case KEY_PAGE_UP:               
+                case KEY_PAGE_DOWN:             
+                case KEY_END:                   
+                case KEY_HOME:                  
+                case KEY_LEFT:                  
+                case KEY_UP:                    
+                case KEY_RIGHT:                 
+                case KEY_DOWN:                  
+                case KEY_INSERT:                
+                case KEY_DELETE:
+                        // These will be handled                
+                break;
+                
+                default:
+                        // regular ASCII characters will also be handled
+                        if(key_code >= KEY_SPECIAL)
+                        {
+                                // Other "special" codes will not work properly.
+                                result = false;
+                        }
+                break;
+        }
+        
+        if(result)
+        {
+                LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "key_event");
+                std::string temp;
+                switch(type)
+                {
+                        case KEY_EVENT_DOWN:                    temp = "down";                  break;
+                        case KEY_EVENT_UP:                              temp = "up";                    break;
+                        case KEY_EVENT_REPEAT:                  temp = "repeat";                break;
+                }
+                message.setValue("event", temp);
+                
+                message.setValueS32("key", key_code);
+
+                message.setValue("modifiers", translateModifiers(modifiers));
+                message.setValueLLSD("native_key_data", native_key_data);
+                
+                sendMessage(message);
+        }
+                
+        return result;
+}
+
+void LLPluginClassMedia::scrollEvent(int x, int y, MASK modifiers)
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "scroll_event");
+
+        message.setValueS32("x", x);
+        message.setValueS32("y", y);
+        message.setValue("modifiers", translateModifiers(modifiers));
+        
+        sendMessage(message);
+}
+        
+bool LLPluginClassMedia::textInput(const std::string &text, MASK modifiers, LLSD native_key_data)
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "text_event");
+
+        message.setValue("text", text);
+        message.setValue("modifiers", translateModifiers(modifiers));
+        message.setValueLLSD("native_key_data", native_key_data);
+        
+        sendMessage(message);
+        
+        return true;
+}
+
+void LLPluginClassMedia::loadURI(const std::string &uri)
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "load_uri");
+
+        message.setValue("uri", uri);
+        
+        sendMessage(message);
+}
+
+const char* LLPluginClassMedia::priorityToString(EPriority priority)
+{
+        const char* result = "UNKNOWN";
+        switch(priority)
+        {
+                case PRIORITY_UNLOADED:         result = "unloaded";    break;
+                case PRIORITY_STOPPED:          result = "stopped";             break;
+                case PRIORITY_HIDDEN:           result = "hidden";              break;
+                case PRIORITY_SLIDESHOW:        result = "slideshow";   break;
+                case PRIORITY_LOW:                      result = "low";                 break;
+                case PRIORITY_NORMAL:           result = "normal";              break;
+                case PRIORITY_HIGH:                     result = "high";                break;
+        }
+        
+        return result;
+}
+
+void LLPluginClassMedia::setPriority(EPriority priority)
+{
+        if(mPriority != priority)
+        {
+                mPriority = priority;
+
+                LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "set_priority");
+                
+                std::string priority_string = priorityToString(priority);
+                switch(priority)
+                {
+                        case PRIORITY_UNLOADED: 
+                                mSleepTime = 1.0f;
+                        break;
+                        case PRIORITY_STOPPED:  
+                                mSleepTime = 1.0f;
+                        break;
+                        case PRIORITY_HIDDEN:   
+                                mSleepTime = 1.0f;
+                        break;
+                        case PRIORITY_SLIDESHOW:
+                                mSleepTime = 1.0f;
+                        break;
+                        case PRIORITY_LOW:              
+                                mSleepTime = 1.0f / 25.0f;
+                        break;
+                        case PRIORITY_NORMAL:   
+                                mSleepTime = 1.0f / 50.0f;
+                        break;
+                        case PRIORITY_HIGH:             
+                                mSleepTime = 1.0f / 100.0f;
+                        break;
+                }
+                
+                message.setValue("priority", priority_string);
+
+                sendMessage(message);
+                
+                if(mPlugin)
+                {
+                        mPlugin->setSleepTime(mSleepTime);
+                }
+                
+                LL_DEBUGS("PluginPriority") << this << ": setting priority to " << priority_string << LL_ENDL;
+                
+                // This may affect the calculated size, so recalculate it here.
+                setSizeInternal();
+        }
+}
+
+void LLPluginClassMedia::setLowPrioritySizeLimit(int size)
+{
+        int power = nextPowerOf2(size);
+        if(mLowPrioritySizeLimit != power)
+        {
+                mLowPrioritySizeLimit = power;
+
+                // This may affect the calculated size, so recalculate it here.
+                setSizeInternal();
+        }
+}
+
+F64 LLPluginClassMedia::getCPUUsage()
+{
+        F64 result = 0.0f;
+        
+        if(mPlugin)
+        {
+                result = mPlugin->getCPUUsage();
+        }
+        
+        return result;
+}
+
+void LLPluginClassMedia::cut()
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "edit_cut");
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::copy()
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "edit_copy");
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::paste()
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "edit_paste");
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::setUserDataPath(const std::string &user_data_path)
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "set_user_data_path");
+        message.setValue("path", user_data_path);
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::setLanguageCode(const std::string &language_code)
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "set_language_code");
+        message.setValue("language", language_code);
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::setPluginsEnabled(const bool enabled)
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "plugins_enabled");
+        message.setValueBoolean("enable", enabled);
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::setJavascriptEnabled(const bool enabled)
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "javascript_enabled");
+        message.setValueBoolean("enable", enabled);
+        sendMessage(message);
+}
+
+/* virtual */ 
+void LLPluginClassMedia::receivePluginMessage(const LLPluginMessage &message)
+{
+        std::string message_class = message.getClass();
+        
+        if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA)
+        {
+                std::string message_name = message.getName();
+                if(message_name == "texture_params")
+                {
+                        mRequestedTextureDepth = message.getValueS32("depth");
+                        mRequestedTextureInternalFormat = message.getValueU32("internalformat");
+                        mRequestedTextureFormat = message.getValueU32("format");
+                        mRequestedTextureType = message.getValueU32("type");
+                        mRequestedTextureSwapBytes = message.getValueBoolean("swap_bytes");
+                        mRequestedTextureCoordsOpenGL = message.getValueBoolean("coords_opengl");                       
+                        
+                        // These two are optional, and will default to 0 if they're not specified.
+                        mDefaultMediaWidth = message.getValueS32("default_width");
+                        mDefaultMediaHeight = message.getValueS32("default_height");
+                        
+                        mAllowDownsample = message.getValueBoolean("allow_downsample");
+                        mPadding = message.getValueS32("padding");
+
+                        setSizeInternal();
+                        
+                        mTextureParamsReceived = true;
+                }
+                else if(message_name == "updated")
+                {                       
+                        if(message.hasValue("left"))
+                        {
+                                LLRect newDirtyRect;
+                                newDirtyRect.mLeft = message.getValueS32("left");
+                                newDirtyRect.mTop = message.getValueS32("top");
+                                newDirtyRect.mRight = message.getValueS32("right");
+                                newDirtyRect.mBottom = message.getValueS32("bottom");
+                                                        
+                                // The plugin is likely to have top and bottom switched, due to vertical flip and OpenGL coordinate confusion.
+                                // If they're backwards, swap them.
+                                if(newDirtyRect.mTop < newDirtyRect.mBottom)
+                                {
+                                        S32 temp = newDirtyRect.mTop;
+                                        newDirtyRect.mTop = newDirtyRect.mBottom;
+                                        newDirtyRect.mBottom = temp;
+                                }
+                                
+                                if(mDirtyRect.isEmpty())
+                                {
+                                        mDirtyRect = newDirtyRect;
+                                }
+                                else
+                                {
+                                        mDirtyRect.unionWith(newDirtyRect);
+                                }
+
+                                LL_DEBUGS("PluginClassMediaRect") << "adjusted incoming rect is: ("
+                                        << newDirtyRect.mLeft << ", "
+                                        << newDirtyRect.mTop << ", "
+                                        << newDirtyRect.mRight << ", "
+                                        << newDirtyRect.mBottom << "), new dirty rect is: ("
+                                        << mDirtyRect.mLeft << ", "
+                                        << mDirtyRect.mTop << ", "
+                                        << mDirtyRect.mRight << ", "
+                                        << mDirtyRect.mBottom << ")"
+                                        << LL_ENDL;
+                                
+                                mediaEvent(LLPluginClassMediaOwner::MEDIA_EVENT_CONTENT_UPDATED);
+                        }                       
+                        
+
+                        bool time_duration_updated = false;
+                        int previous_percent = mProgressPercent;
+
+                        if(message.hasValue("current_time"))
+                        {
+                                mCurrentTime = message.getValueReal("current_time");
+                                time_duration_updated = true;
+                        }
+                        if(message.hasValue("duration"))
+                        {
+                                mDuration = message.getValueReal("duration");
+                                time_duration_updated = true;
+                        }
+
+                        if(message.hasValue("current_rate"))
+                        {
+                                mCurrentRate = message.getValueReal("current_rate");
+                        }
+                        
+                        if(message.hasValue("loaded_duration"))
+                        {
+                                mLoadedDuration = message.getValueReal("loaded_duration");
+                                time_duration_updated = true;
+                        }
+                        else
+                        {
+                                // If the message doesn't contain a loaded_duration param, assume it's equal to duration
+                                mLoadedDuration = mDuration;
+                        }
+                        
+                        // Calculate a percentage based on the loaded duration and total duration.
+                        if(mDuration != 0.0f)   // Don't divide by zero.
+                        {
+                                mProgressPercent = (int)((mLoadedDuration * 100.0f)/mDuration);
+                        }
+
+                        if(time_duration_updated)
+                        {
+                                mediaEvent(LLPluginClassMediaOwner::MEDIA_EVENT_TIME_DURATION_UPDATED);
+                        }
+                        
+                        if(previous_percent != mProgressPercent)
+                        {
+                                mediaEvent(LLPluginClassMediaOwner::MEDIA_EVENT_PROGRESS_UPDATED);
+                        }
+                }
+                else if(message_name == "media_status")
+                {
+                        std::string status = message.getValue("status");
+
+                        LL_DEBUGS("PluginClassMedia") << "Status changed to: " << status << LL_ENDL;
+
+                        if(status == "loading")
+                        {
+                                mStatus = LLPluginClassMediaOwner::MEDIA_LOADING;
+                        }
+                        else if(status == "loaded")
+                        {
+                                mStatus = LLPluginClassMediaOwner::MEDIA_LOADED;
+                        }
+                        else if(status == "error")
+                        {
+                                mStatus = LLPluginClassMediaOwner::MEDIA_ERROR;
+                        }
+                        else if(status == "playing")
+                        {
+                                mStatus = LLPluginClassMediaOwner::MEDIA_PLAYING;
+                        }
+                        else if(status == "paused")
+                        {
+                                mStatus = LLPluginClassMediaOwner::MEDIA_PAUSED;
+                        }
+                        else if(status == "done")
+                        {
+                                mStatus = LLPluginClassMediaOwner::MEDIA_DONE;
+                        }
+                        else
+                        {
+                                // empty string or any unknown string
+                                mStatus = LLPluginClassMediaOwner::MEDIA_NONE;
+                        }
+                }
+                else if(message_name == "size_change_request")
+                {
+                        S32 width = message.getValueS32("width");
+                        S32 height = message.getValueS32("height");
+                        std::string name = message.getValue("name");
+
+                        // TODO: check that name matches?
+                        mNaturalMediaWidth = width;
+                        mNaturalMediaHeight = height;
+                        
+                        setSizeInternal();
+                }
+                else if(message_name == "size_change_response")
+                {
+                        std::string name = message.getValue("name");
+                        
+                        // TODO: check that name matches?
+                        
+                        mTextureWidth = message.getValueS32("texture_width");
+                        mTextureHeight = message.getValueS32("texture_height");
+                        mMediaWidth = message.getValueS32("width");
+                        mMediaHeight = message.getValueS32("height");
+                        
+                        // This invalidates any existing dirty rect.
+                        resetDirty();
+                        
+                        // TODO: should we verify that the plugin sent back the right values?  
+                        // Two size changes in a row may cause them to not match, due to queueing, etc.
+
+                        mediaEvent(LLPluginClassMediaOwner::MEDIA_EVENT_SIZE_CHANGED);
+                }
+                else if(message_name == "cursor_changed")
+                {
+                        mCursorName = message.getValue("name");
+
+                        mediaEvent(LLPluginClassMediaOwner::MEDIA_EVENT_CURSOR_CHANGED);
+                }
+                else if(message_name == "edit_state")
+                {
+                        if(message.hasValue("cut"))
+                        {
+                                mCanCut = message.getValueBoolean("cut");
+                        }
+                        if(message.hasValue("copy"))
+                        {
+                                mCanCopy = message.getValueBoolean("copy");
+                        }
+                        if(message.hasValue("paste"))
+                        {
+                                mCanPaste = message.getValueBoolean("paste");
+                        }
+                }
+                else if(message_name == "name_text")
+                {
+                        mMediaName = message.getValue("name");
+                        mediaEvent(LLPluginClassMediaOwner::MEDIA_EVENT_NAME_CHANGED);
+                }
+                else
+                {
+                        LL_WARNS("PluginClassMedia") << "Unknown " << message_name << " class message: " << message_name << LL_ENDL;
+                }
+        }
+        else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER)
+        {
+                std::string message_name = message.getName();
+                if(message_name == "navigate_begin")
+                {
+                        mNavigateURI = message.getValue("uri");
+                        mediaEvent(LLPluginClassMediaOwner::MEDIA_EVENT_NAVIGATE_BEGIN);
+                }
+                else if(message_name == "navigate_complete")
+                {
+                        mNavigateURI = message.getValue("uri");
+                        mNavigateResultCode = message.getValueS32("result_code");
+                        mNavigateResultString = message.getValue("result_string");
+                        mHistoryBackAvailable = message.getValueBoolean("history_back_available");
+                        mHistoryForwardAvailable = message.getValueBoolean("history_forward_available");
+                        
+                        mediaEvent(LLPluginClassMediaOwner::MEDIA_EVENT_NAVIGATE_COMPLETE);
+                }
+                else if(message_name == "progress")
+                {
+                        mProgressPercent = message.getValueS32("percent");
+                        mediaEvent(LLPluginClassMediaOwner::MEDIA_EVENT_PROGRESS_UPDATED);
+                }
+                else if(message_name == "status_text")
+                {
+                        mStatusText = message.getValue("status");
+                        mediaEvent(LLPluginClassMediaOwner::MEDIA_EVENT_STATUS_TEXT_CHANGED);
+                }
+                else if(message_name == "location_changed")
+                {
+                        mLocation = message.getValue("uri");
+                        mediaEvent(LLPluginClassMediaOwner::MEDIA_EVENT_LOCATION_CHANGED);
+                }
+                else if(message_name == "click_href")
+                {
+                        mClickURL = message.getValue("uri");
+                        mClickTarget = message.getValue("target");
+                        LL_DEBUGS("PluginClassMedia") << "Click target \"" << mClickTarget << "\"" << LL_ENDL;
+                        mediaEvent(LLPluginClassMediaOwner::MEDIA_EVENT_CLICK_LINK_HREF);
+                }
+                else if(message_name == "click_nofollow")
+                {
+                        mClickURL = message.getValue("uri");
+                        mClickTarget.clear();
+                        mediaEvent(LLPluginClassMediaOwner::MEDIA_EVENT_CLICK_LINK_NOFOLLOW);
+                }
+                else if(message_name == "cookie_set")
+                {
+                        if(mOwner)
+                        {
+                                mOwner->handleCookieSet(this, message.getValue("cookie"));
+                        }
+                }
+                else
+                {
+                        LL_WARNS("PluginClassMedia") << "Unknown " << message_name << " class message: " << message_name << LL_ENDL;
+                }
+        }
+        else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME)
+        {
+                std::string message_name = message.getName();
+
+                // This class hasn't defined any incoming messages yet.
+//              if(message_name == "message_name")
+//              {
+//              }
+//              else
+                {
+                        LL_WARNS("PluginClassMedia") << "Unknown " << message_name << " class message: " << message_name << LL_ENDL;
+                }
+        }
+
+}
+
+/* virtual */ 
+void LLPluginClassMedia::pluginLaunchFailed()
+{
+        mediaEvent(LLPluginClassMediaOwner::MEDIA_EVENT_PLUGIN_FAILED_LAUNCH);
+}
+
+/* virtual */ 
+void LLPluginClassMedia::pluginDied()
+{
+        mediaEvent(LLPluginClassMediaOwner::MEDIA_EVENT_PLUGIN_FAILED);
+}
+
+void LLPluginClassMedia::mediaEvent(LLPluginClassMediaOwner::EMediaEvent event)
+{
+        if(mOwner)
+        {
+                mOwner->handleMediaEvent(this, event);
+        }
+}
+
+void LLPluginClassMedia::sendMessage(const LLPluginMessage &message)
+{
+        if(mPlugin && mPlugin->isRunning())
+        {
+                mPlugin->sendMessage(message);
+        }
+        else
+        {
+                // The plugin isn't set up yet -- queue this message to be sent after initialization.
+                mSendQueue.push(message);
+        }
+}
+
+////////////////////////////////////////////////////////////
+// MARK: media_browser class functions
+bool LLPluginClassMedia::pluginSupportsMediaBrowser(void)
+{
+        std::string version = mPlugin->getMessageClassVersion(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER);
+        return !version.empty();
+}
+
+void LLPluginClassMedia::focus(bool focused)
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "focus");
+
+        message.setValueBoolean("focused", focused);
+        
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::clear_cache()
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "clear_cache");
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::clear_cookies()
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "clear_cookies");
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::set_cookies(const std::string &cookies)
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "set_cookies");
+        message.setValue("cookies", cookies);   
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::enable_cookies(bool enable)
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "enable_cookies");
+        message.setValueBoolean("enable", enable);
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::proxy_setup(bool enable, const std::string &host, int port)
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "proxy_setup");
+
+        message.setValueBoolean("enable", enable);
+        message.setValue("host", host);
+        message.setValueS32("port", port);
+
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::browse_stop()
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "browse_stop");
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::browse_reload(bool ignore_cache)
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "browse_reload");
+
+        message.setValueBoolean("ignore_cache", ignore_cache);
+        
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::browse_forward()
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "browse_forward");
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::browse_back()
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "browse_back");
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::set_status_redirect(int code, const std::string &url)
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "set_status_redirect");
+
+        message.setValueS32("code", code);
+        message.setValue("url", url);
+
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::setBrowserUserAgent(const std::string& user_agent)
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "set_user_agent");
+
+        message.setValue("user_agent", user_agent);
+
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::crashPlugin()
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "crash");
+
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::hangPlugin()
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "hang");
+
+        sendMessage(message);
+}
+
+
+////////////////////////////////////////////////////////////
+// MARK: media_time class functions
+bool LLPluginClassMedia::pluginSupportsMediaTime(void)
+{
+        std::string version = mPlugin->getMessageClassVersion(LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME);
+        return !version.empty();
+}
+
+void LLPluginClassMedia::stop()
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME, "stop");
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::start(float rate)
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME, "start");
+
+        message.setValueReal("rate", rate);
+
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::pause()
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME, "pause");
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::seek(float time)
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME, "seek");
+
+        message.setValueReal("time", time);
+        
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::setLoop(bool loop)
+{
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME, "set_loop");
+
+        message.setValueBoolean("loop", loop);
+
+        sendMessage(message);
+}
+
+void LLPluginClassMedia::setVolume(float volume)
+{
+        if(volume != mRequestedVolume)
+        {
+                mRequestedVolume = volume;
+                
+                LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME, "set_volume");
+
+                message.setValueReal("volume", volume);
+                
+                sendMessage(message);
+        }
+}
+
+float LLPluginClassMedia::getVolume()
+{
+        return mRequestedVolume;
+}
+
+void LLPluginClassMedia::initializeUrlHistory(const LLSD& url_history)
+{
+        // Send URL history to plugin
+        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "init_history");
+        message.setValueLLSD("history", url_history);
+        sendMessage(message);
+
+        LL_DEBUGS("PluginClassMedia") << "Sending history" << LL_ENDL;
+}
+
diff --git a/linden/indra/llplugin/llpluginclassmedia.h b/linden/indra/llplugin/llpluginclassmedia.h
new file mode 100755
index 0000000..0004971
--- /dev/null
+++ b/linden/indra/llplugin/llpluginclassmedia.h
@@ -0,0 +1,377 @@
+/** 
+ * @file llpluginclassmedia.h
+ * @brief LLPluginClassMedia handles interaction with a plugin which knows about the "media" message class.
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+#ifndef LL_LLPLUGINCLASSMEDIA_H
+#define LL_LLPLUGINCLASSMEDIA_H
+
+#include "llgltypes.h"
+#include "llpluginprocessparent.h"
+#include "llrect.h"
+#include "llpluginclassmediaowner.h"
+#include <queue>
+#include "v4color.h"
+
+class LLPluginClassMedia : public LLPluginProcessParentOwner
+{
+        LOG_CLASS(LLPluginClassMedia);
+public:
+        LLPluginClassMedia(LLPluginClassMediaOwner *owner);
+        virtual ~LLPluginClassMedia();
+
+        // local initialization, called by the media manager when creating a source
+        virtual bool init(const std::string &launcher_filename, 
+                                          const std::string &plugin_filename, 
+                                          bool debug);
+
+        // undoes everything init() didm called by the media manager when destroying a source
+        virtual void reset();
+        
+        void idle(void);
+        
+        // All of these may return 0 or an actual valid value.
+        // Callers need to check the return for 0, and not use the values in that case.
+        int getWidth() const { return (mMediaWidth > 0) ? mMediaWidth : 0; };
+        int getHeight() const { return (mMediaHeight > 0) ? mMediaHeight : 0; };
+        int getNaturalWidth() const { return mNaturalMediaWidth; };
+        int getNaturalHeight() const { return mNaturalMediaHeight; };
+        int getSetWidth() const { return mSetMediaWidth; };
+        int getSetHeight() const { return mSetMediaHeight; };
+        int getBitsWidth() const { return (mTextureWidth > 0) ? mTextureWidth : 0; };
+        int getBitsHeight() const { return (mTextureHeight > 0) ? mTextureHeight : 0; };
+        int getTextureWidth() const;
+        int getTextureHeight() const;
+        int getFullWidth() const { return mFullMediaWidth; };
+        int getFullHeight() const { return mFullMediaHeight; };
+        
+        // This may return NULL.  Callers need to check for and handle this case.
+        unsigned char* getBitsData();
+
+        // gets the format details of the texture data
+        // These may return 0 if they haven't been set up yet.  The caller needs to detect this case.
+        int getTextureDepth() const { return mRequestedTextureDepth; };
+        int getTextureFormatInternal() const { return mRequestedTextureInternalFormat; };
+        int getTextureFormatPrimary() const { return mRequestedTextureFormat; };
+        int getTextureFormatType() const { return mRequestedTextureType; };
+        bool getTextureFormatSwapBytes() const { return mRequestedTextureSwapBytes; };
+        bool getTextureCoordsOpenGL() const { return mRequestedTextureCoordsOpenGL; };
+
+        void setSize(int width, int height);
+        void setAutoScale(bool auto_scale);
+        
+        void setBackgroundColor(LLColor4 color) { mBackgroundColor = color; };
+        
+        // Returns true if all of the texture parameters (depth, format, size, and texture size) are set up and consistent.
+        // This will initially be false, and will also be false for some time after setSize while the resize is processed.
+        // Note that if this returns true, it is safe to use all the get() functions above without checking for invalid return values
+        // until you call idle() again.
+        bool textureValid(void);
+        
+        bool getDirty(LLRect *dirty_rect = NULL);
+        void resetDirty(void);
+        
+        typedef enum 
+        {
+                MOUSE_EVENT_DOWN,
+                MOUSE_EVENT_UP,
+                MOUSE_EVENT_MOVE,
+                MOUSE_EVENT_DOUBLE_CLICK
+        }EMouseEventType;
+        
+        void mouseEvent(EMouseEventType type, int button, int x, int y, MASK modifiers);
+
+        typedef enum 
+        {
+                KEY_EVENT_DOWN,
+                KEY_EVENT_UP,
+                KEY_EVENT_REPEAT
+        }EKeyEventType;
+        
+        bool keyEvent(EKeyEventType type, int key_code, MASK modifiers, LLSD native_key_data);
+
+        void scrollEvent(int x, int y, MASK modifiers);
+        
+        // Text may be unicode (utf8 encoded)
+        bool textInput(const std::string &text, MASK modifiers, LLSD native_key_data);
+        
+        void loadURI(const std::string &uri);
+        
+        // "Loading" means uninitialized or any state prior to fully running (processing commands)
+        bool isPluginLoading(void) { return mPlugin?mPlugin->isLoading():false; };
+
+        // "Running" means the steady state -- i.e. processing messages
+        bool isPluginRunning(void) { return mPlugin?mPlugin->isRunning():false; };
+        
+        // "Exited" means any regular or error state after "Running" (plugin may have crashed or exited normally)
+        bool isPluginExited(void) { return mPlugin?mPlugin->isDone():false; };
+
+        std::string getPluginVersion() { return mPlugin?mPlugin->getPluginVersion():std::string(""); };
+
+        bool getDisableTimeout() { return mPlugin?mPlugin->getDisableTimeout():false; };
+        void setDisableTimeout(bool disable) { if(mPlugin) mPlugin->setDisableTimeout(disable); };
+        
+        // Inherited from LLPluginProcessParentOwner
+        /* virtual */ void receivePluginMessage(const LLPluginMessage &message);
+        /* virtual */ void pluginLaunchFailed();
+        /* virtual */ void pluginDied();
+        
+        
+        typedef enum 
+        {
+                PRIORITY_UNLOADED,      // media plugin isn't even loaded.
+                PRIORITY_STOPPED,       // media is not playing, shouldn't need to update at all.
+                PRIORITY_HIDDEN,        // media is not being displayed or is out of view, don't need to do graphic updates, but may still update audio, playhead, etc.
+                PRIORITY_SLIDESHOW,     // media is in the far distance, updates very infrequently
+                PRIORITY_LOW,           // media is in the distance, may be rendered at reduced size
+                PRIORITY_NORMAL,        // normal (default) priority
+                PRIORITY_HIGH           // media has user focus and/or is taking up most of the screen
+        }EPriority;
+
+        static const char* priorityToString(EPriority priority);
+        void setPriority(EPriority priority);
+        void setLowPrioritySizeLimit(int size);
+        
+        F64 getCPUUsage();
+
+        // Valid after a MEDIA_EVENT_CURSOR_CHANGED event
+        std::string getCursorName() const { return mCursorName; };
+
+        LLPluginClassMediaOwner::EMediaStatus getStatus() const { return mStatus; }
+
+        void    cut();
+        bool    canCut() const { return mCanCut; };
+
+        void    copy();
+        bool    canCopy() const { return mCanCopy; };
+
+        void    paste();
+        bool    canPaste() const { return mCanPaste; };
+        
+        // These can be called before init(), and they will be queued and sent before the media init message.
+        void    setUserDataPath(const std::string &user_data_path);
+        void    setLanguageCode(const std::string &language_code);
+        void    setPluginsEnabled(const bool enabled);
+        void    setJavascriptEnabled(const bool enabled);
+                
+        ///////////////////////////////////
+        // media browser class functions
+        bool pluginSupportsMediaBrowser(void);
+        
+        void focus(bool focused);
+        void clear_cache();
+        void clear_cookies();
+        void set_cookies(const std::string &cookies);
+        void enable_cookies(bool enable);
+        void proxy_setup(bool enable, const std::string &host = LLStringUtil::null, int port = 0);
+        void browse_stop();
+        void browse_reload(bool ignore_cache = false);
+        void browse_forward();
+        void browse_back();
+        void set_status_redirect(int code, const std::string &url);
+        void setBrowserUserAgent(const std::string& user_agent);
+        
+        // This is valid after MEDIA_EVENT_NAVIGATE_BEGIN or MEDIA_EVENT_NAVIGATE_COMPLETE
+        std::string     getNavigateURI() const { return mNavigateURI; };
+
+        // These are valid after MEDIA_EVENT_NAVIGATE_COMPLETE
+        S32                     getNavigateResultCode() const { return mNavigateResultCode; };
+        std::string getNavigateResultString() const { return mNavigateResultString; };
+        bool            getHistoryBackAvailable() const { return mHistoryBackAvailable; };
+        bool            getHistoryForwardAvailable() const { return mHistoryForwardAvailable; };
+
+        // This is valid after MEDIA_EVENT_PROGRESS_UPDATED
+        int                     getProgressPercent() const { return mProgressPercent; };
+        
+        // This is valid after MEDIA_EVENT_STATUS_TEXT_CHANGED
+        std::string getStatusText() const { return mStatusText; };
+        
+        // This is valid after MEDIA_EVENT_LOCATION_CHANGED
+        std::string getLocation() const { return mLocation; };
+        
+        // This is valid after MEDIA_EVENT_CLICK_LINK_HREF or MEDIA_EVENT_CLICK_LINK_NOFOLLOW
+        std::string getClickURL() const { return mClickURL; };
+
+        // This is valid after MEDIA_EVENT_CLICK_LINK_HREF
+        std::string getClickTarget() const { return mClickTarget; };
+
+
+        std::string getMediaName() const { return mMediaName; };
+        std::string getMediaDescription() const { return mMediaDescription; };
+
+        // Crash the plugin.  If you use this outside of a testbed, you will be punished.
+        void            crashPlugin();
+        
+        // Hang the plugin.  If you use this outside of a testbed, you will be punished.
+        void            hangPlugin();
+
+        ///////////////////////////////////
+        // media time class functions
+        bool pluginSupportsMediaTime(void);
+        void stop();
+        void start(float rate = 0.0f);
+        void pause();
+        void seek(float time);
+        void setLoop(bool loop);
+        void setVolume(float volume);
+        float getVolume();
+        
+        F64 getCurrentTime(void) const { return mCurrentTime; };
+        F64 getDuration(void) const { return mDuration; };
+        F64 getCurrentPlayRate(void) { return mCurrentRate; };
+        F64 getLoadedDuration(void) const { return mLoadedDuration; };
+        
+        // Initialize the URL history of the plugin by sending
+        // "init_history" message 
+        void initializeUrlHistory(const LLSD& url_history);
+
+protected:
+
+        LLPluginClassMediaOwner *mOwner;
+
+        // Notify this object's owner that an event has occurred.
+        void mediaEvent(LLPluginClassMediaOwner::EMediaEvent event);
+                
+        void sendMessage(const LLPluginMessage &message);  // Send message internally, either queueing or sending directly.
+        std::queue<LLPluginMessage> mSendQueue;         // Used to queue messages while the plugin initializes.
+        
+        void setSizeInternal(void);
+
+        bool            mTextureParamsReceived;         // the mRequestedTexture* fields are only valid when this is true
+        S32             mRequestedTextureDepth;
+        LLGLenum        mRequestedTextureInternalFormat;
+        LLGLenum        mRequestedTextureFormat;
+        LLGLenum        mRequestedTextureType;
+        bool            mRequestedTextureSwapBytes;
+        bool            mRequestedTextureCoordsOpenGL;
+        
+        std::string mTextureSharedMemoryName;
+        size_t          mTextureSharedMemorySize;
+        
+        // True to scale requested media up to the full size of the texture (i.e. next power of two)
+        bool            mAutoScaleMedia;
+
+        // default media size for the plugin, from the texture_params message.
+        int                     mDefaultMediaWidth;
+        int                     mDefaultMediaHeight;
+
+        // Size that has been requested by the plugin itself
+        int                     mNaturalMediaWidth;
+        int                     mNaturalMediaHeight;
+
+        // Size that has been requested with setSize()
+        int                     mSetMediaWidth;
+        int                     mSetMediaHeight;
+        
+        // Full calculated media size (before auto-scale and downsample calculations)
+        int                     mFullMediaWidth;
+        int                     mFullMediaHeight;
+
+        // Actual media size being set (after auto-scale)
+        int                     mRequestedMediaWidth;
+        int                     mRequestedMediaHeight;
+        
+        // Texture size calculated from actual media size
+        int                     mRequestedTextureWidth;
+        int                     mRequestedTextureHeight;
+        
+        // Size that the plugin has acknowledged
+        int                     mTextureWidth;
+        int                     mTextureHeight;
+        int                     mMediaWidth;
+        int                     mMediaHeight;
+        
+        float           mRequestedVolume;
+        
+        // Priority of this media stream
+        EPriority       mPriority;
+        int                     mLowPrioritySizeLimit;
+        
+        bool            mAllowDownsample;
+        int                     mPadding;
+        
+        
+        LLPluginProcessParent *mPlugin;
+        
+        LLRect mDirtyRect;
+        
+        std::string translateModifiers(MASK modifiers);
+        
+        std::string mCursorName;
+        int                     mLastMouseX;
+        int                     mLastMouseY;
+
+        LLPluginClassMediaOwner::EMediaStatus mStatus;
+        
+        F64                             mSleepTime;
+
+        bool                    mCanCut;
+        bool                    mCanCopy;
+        bool                    mCanPaste;
+        
+        std::string             mMediaName;
+        std::string             mMediaDescription;
+        
+        LLColor4                mBackgroundColor;
+        
+        /////////////////////////////////////////
+        // media_browser class
+        std::string             mNavigateURI;
+        S32                             mNavigateResultCode;
+        std::string             mNavigateResultString;
+        bool                    mHistoryBackAvailable;
+        bool                    mHistoryForwardAvailable;
+        std::string             mStatusText;
+        int                             mProgressPercent;
+        std::string             mLocation;
+        std::string             mClickURL;
+        std::string             mClickTarget;
+        
+        /////////////////////////////////////////
+        // media_time class
+        F64                             mCurrentTime;
+        F64                             mDuration;
+        F64                             mCurrentRate;
+        F64                             mLoadedDuration;
+        
+//--------------------------------------
+        //debug use only
+        //
+private:
+        bool  mDeleteOK ;
+public:
+        void setDeleteOK(bool flag) { mDeleteOK = flag ;}
+//--------------------------------------
+};
+
+#endif // LL_LLPLUGINCLASSMEDIA_H
diff --git a/linden/indra/llplugin/llpluginclassmediaowner.h b/linden/indra/llplugin/llpluginclassmediaowner.h
new file mode 100755
index 0000000..0e54f7f
--- /dev/null
+++ b/linden/indra/llplugin/llpluginclassmediaowner.h
@@ -0,0 +1,87 @@
+/** 
+ * @file llpluginclassmediaowner.h
+ * @brief LLPluginClassMedia handles interaction with a plugin which knows about the "media" message class.
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+#ifndef LL_LLPLUGINCLASSMEDIAOWNER_H
+#define LL_LLPLUGINCLASSMEDIAOWNER_H
+
+#include "llpluginprocessparent.h"
+#include "llrect.h"
+#include <queue>
+
+class LLPluginClassMedia;
+//class LLPluginCookieStore; // IMPRUDENCE: this is currently not used 
+
+class LLPluginClassMediaOwner
+{
+public:
+        typedef enum
+        {
+                MEDIA_EVENT_CONTENT_UPDATED,            // contents/dirty rect have updated 
+                MEDIA_EVENT_TIME_DURATION_UPDATED,      // current time and/or duration have updated
+                MEDIA_EVENT_SIZE_CHANGED,                       // media size has changed
+                MEDIA_EVENT_CURSOR_CHANGED,                     // plugin has requested a cursor change
+                
+                MEDIA_EVENT_NAVIGATE_BEGIN,                     // browser has begun navigation
+                MEDIA_EVENT_NAVIGATE_COMPLETE,          // browser has finished navigation
+                MEDIA_EVENT_PROGRESS_UPDATED,           // browser has updated loading progress
+                MEDIA_EVENT_STATUS_TEXT_CHANGED,        // browser has updated the status text
+                MEDIA_EVENT_NAME_CHANGED,                       // browser has updated the name of the media (typically <title> tag)
+                MEDIA_EVENT_LOCATION_CHANGED,           // browser location (URL) has changed (maybe due to internal navagation/frames/etc)
+                MEDIA_EVENT_CLICK_LINK_HREF,            // I'm not entirely sure what the semantics of these two are
+                MEDIA_EVENT_CLICK_LINK_NOFOLLOW,
+                
+                MEDIA_EVENT_PLUGIN_FAILED_LAUNCH,       // The plugin failed to launch 
+                MEDIA_EVENT_PLUGIN_FAILED                       // The plugin died unexpectedly
+                
+        } EMediaEvent;
+        
+        typedef enum
+        {
+                MEDIA_NONE,                     // Uninitialized -- no useful state
+                MEDIA_LOADING,          // loading or navigating
+                MEDIA_LOADED,           // navigation/preroll complete
+                MEDIA_ERROR,            // navigation/preroll failed
+                MEDIA_PLAYING,          // playing (only for time-based media)
+                MEDIA_PAUSED,           // paused (only for time-based media)
+                MEDIA_DONE                      // finished playing (only for time-based media)
+        
+        } EMediaStatus;
+        
+        virtual ~LLPluginClassMediaOwner() {};
+        virtual void handleMediaEvent(LLPluginClassMedia* /*self*/, EMediaEvent /*event*/) {};
+        virtual void handleCookieSet(LLPluginClassMedia* /*self*/, const std::string &/*cookie*/) {};
+};
+
+#endif // LL_LLPLUGINCLASSMEDIAOWNER_H
diff --git a/linden/indra/llplugin/llplugincookiestore.cpp b/linden/indra/llplugin/llplugincookiestore.cpp
new file mode 100644
index 0000000..6b193de
--- /dev/null
+++ b/linden/indra/llplugin/llplugincookiestore.cpp
@@ -0,0 +1,673 @@
+/** 
+ * @file llplugincookiestore.cpp
+ * @brief LLPluginCookieStore provides central storage for http cookies used by plugins
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2010&license=viewergpl$
+ * 
+ * Copyright (c) 2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+/// IMPRUDENCE: this is currently not used
+
+#include "linden_common.h"
+#include "indra_constants.h"
+
+#include "llplugincookiestore.h"
+#include <iostream>
+
+// for curl_getdate() (apparently parsing RFC 1123 dates is hard)
+#include <curl/curl.h>
+
+LLPluginCookieStore::LLPluginCookieStore():
+        mHasChangedCookies(false)
+{
+}
+
+
+LLPluginCookieStore::~LLPluginCookieStore()
+{
+        clearCookies();
+}
+
+
+LLPluginCookieStore::Cookie::Cookie(const std::string &s, std::string::size_type cookie_start, std::string::size_type cookie_end):
+        mCookie(s, cookie_start, cookie_end - cookie_start),
+        mNameStart(0), mNameEnd(0),
+        mValueStart(0), mValueEnd(0),
+        mDomainStart(0), mDomainEnd(0),
+        mPathStart(0), mPathEnd(0),
+        mDead(false), mChanged(true)
+{
+}
+
+LLPluginCookieStore::Cookie *LLPluginCookieStore::Cookie::createFromString(const std::string &s, std::string::size_type cookie_start, std::string::size_type cookie_end, const std::string &host)
+{
+        Cookie *result = new Cookie(s, cookie_start, cookie_end);
+
+        if(!result->parse(host))
+        {
+                delete result;
+                result = NULL;
+        }
+        
+        return result;
+}
+
+std::string LLPluginCookieStore::Cookie::getKey() const
+{
+        std::string result;
+        if(mDomainEnd > mDomainStart)
+        {
+                result += mCookie.substr(mDomainStart, mDomainEnd - mDomainStart);
+        }
+        result += ';';
+        if(mPathEnd > mPathStart)
+        {
+                result += mCookie.substr(mPathStart, mPathEnd - mPathStart);
+        }
+        result += ';';
+        result += mCookie.substr(mNameStart, mNameEnd - mNameStart);
+        return result;
+}
+
+bool LLPluginCookieStore::Cookie::parse(const std::string &host)
+{
+        bool first_field = true;
+
+        std::string::size_type cookie_end = mCookie.size();
+        std::string::size_type field_start = 0;
+
+        LL_DEBUGS("CookieStoreParse") << "parsing cookie: " << mCookie << LL_ENDL;
+        while(field_start < cookie_end)
+        {
+                // Finding the start of the next field requires honoring special quoting rules
+                // see the definition of 'quoted-string' in rfc2616 for details
+                std::string::size_type next_field_start = findFieldEnd(field_start);
+
+                // The end of this field should not include the terminating ';' or any trailing whitespace
+                std::string::size_type field_end = mCookie.find_last_not_of("; ", next_field_start);
+                if(field_end == std::string::npos || field_end < field_start)
+                {
+                        // This field was empty or all whitespace.  Set end = start so it shows as empty.
+                        field_end = field_start;
+                }
+                else if (field_end < next_field_start)
+                {
+                        // we actually want the index of the char _after_ what 'last not of' found
+                        ++field_end;
+                }
+                
+                // find the start of the actual name (skip separator and possible whitespace)
+                std::string::size_type name_start = mCookie.find_first_not_of("; ", field_start);
+                if(name_start == std::string::npos || name_start > next_field_start)
+                {
+                        // Again, nothing but whitespace.
+                        name_start = field_start;
+                }
+                
+                // the name and value are separated by the first equals sign
+                std::string::size_type name_value_sep = mCookie.find_first_of("=", name_start);
+                if(name_value_sep == std::string::npos || name_value_sep > field_end)
+                {
+                        // No separator found, so this is a field without an = 
+                        name_value_sep = field_end;
+                }
+                
+                // the name end is before the name-value separator
+                std::string::size_type name_end = mCookie.find_last_not_of("= ", name_value_sep);
+                if(name_end == std::string::npos || name_end < name_start)
+                {
+                        // I'm not sure how we'd hit this case... it seems like it would have to be an empty name.
+                        name_end = name_start;
+                }
+                else if (name_end < name_value_sep)
+                {
+                        // we actually want the index of the char _after_ what 'last not of' found
+                        ++name_end;
+                }
+                
+                // Value is between the name-value sep and the end of the field.
+                std::string::size_type value_start = mCookie.find_first_not_of("= ", name_value_sep);
+                if(value_start == std::string::npos || value_start > field_end)
+                {
+                        // All whitespace or empty value
+                        value_start = field_end;
+                }
+                std::string::size_type value_end = mCookie.find_last_not_of("; ", field_end);
+                if(value_end == std::string::npos || value_end < value_start)
+                {
+                        // All whitespace or empty value
+                        value_end = value_start;
+                }
+                else if (value_end < field_end)
+                {
+                        // we actually want the index of the char _after_ what 'last not of' found
+                        ++value_end;
+                }
+
+                LL_DEBUGS("CookieStoreParse") 
+                        << "    field name: \"" << mCookie.substr(name_start, name_end - name_start) 
+                        << "\", value: \"" << mCookie.substr(value_start, value_end - value_start) << "\""
+                        << LL_ENDL;
+                                
+                // See whether this field is one we know
+                if(first_field)
+                {
+                        // The first field is the name=value pair
+                        mNameStart = name_start;
+                        mNameEnd = name_end;
+                        mValueStart = value_start;
+                        mValueEnd = value_end;
+                        first_field = false;
+                }
+                else
+                {
+                        // Subsequent fields must come from the set in rfc2109
+                        if(matchName(name_start, name_end, "expires"))
+                        {
+                                std::string date_string(mCookie, value_start, value_end - value_start); 
+                                // If the cookie contains an "expires" field, it MUST contain a parsable date.
+                                
+                                // HACK: LLDate apparently can't PARSE an rfc1123-format date, even though it can GENERATE one.
+                                //  The curl function curl_getdate can do this, but I'm hesitant to unilaterally introduce a curl dependency in LLDate.
+#if 1
+                                time_t date = curl_getdate(date_string.c_str(), NULL );
+                                mDate.secondsSinceEpoch((F64)date);
+                                LL_DEBUGS("CookieStoreParse") << "        expire date parsed to: " << mDate.asRFC1123() << LL_ENDL;
+#else
+                                // This doesn't work (rfc1123-format dates cause it to fail)
+                                if(!mDate.fromString(date_string))
+                                {
+                                        // Date failed to parse.
+                                        LL_WARNS("CookieStoreParse") << "failed to parse cookie's expire date: " << date << LL_ENDL;
+                                        return false;
+                                }
+#endif
+                        }
+                        else if(matchName(name_start, name_end, "domain"))
+                        {
+                                mDomainStart = value_start;
+                                mDomainEnd = value_end;
+                        }
+                        else if(matchName(name_start, name_end, "path"))
+                        {
+                                mPathStart = value_start;
+                                mPathEnd = value_end;
+                        }
+                        else if(matchName(name_start, name_end, "max-age"))
+                        {
+                                // TODO: how should we handle this?
+                        }
+                        else if(matchName(name_start, name_end, "secure"))
+                        {
+                                // We don't care about the value of this field (yet)
+                        }
+                        else if(matchName(name_start, name_end, "version"))
+                        {
+                                // We don't care about the value of this field (yet)
+                        }
+                        else if(matchName(name_start, name_end, "comment"))
+                        {
+                                // We don't care about the value of this field (yet)
+                        }
+                        else if(matchName(name_start, name_end, "httponly"))
+                        {
+                                // We don't care about the value of this field (yet)
+                        }
+                        else
+                        {
+                                // An unknown field is a parse failure
+                                LL_WARNS("CookieStoreParse") << "unexpected field name: " << mCookie.substr(name_start, name_end - name_start) << LL_ENDL;
+                                return false;
+                        }
+                        
+                }
+
+                
+                // move on to the next field, skipping this field's separator and any leading whitespace
+                field_start = mCookie.find_first_not_of("; ", next_field_start);
+        }
+                
+        // The cookie MUST have a name
+        if(mNameEnd <= mNameStart)
+                return false;
+        
+        // If the cookie doesn't have a domain, add the current host as the domain.
+        if(mDomainEnd <= mDomainStart)
+        {
+                if(host.empty())
+                {
+                        // no domain and no current host -- this is a parse failure.
+                        return false;
+                }
+                
+                // Figure out whether this cookie ended with a ";" or not...
+                std::string::size_type last_char = mCookie.find_last_not_of(" ");
+                if((last_char != std::string::npos) && (mCookie[last_char] != ';'))
+                {
+                        mCookie += ";";
+                }
+                
+                mCookie += " domain=";
+                mDomainStart = mCookie.size();
+                mCookie += host;
+                mDomainEnd = mCookie.size();
+                
+                LL_DEBUGS("CookieStoreParse") << "added domain (" << mDomainStart << " to " << mDomainEnd << "), new cookie is: " << mCookie << LL_ENDL;
+        }
+
+        // If the cookie doesn't have a path, add "/".
+        if(mPathEnd <= mPathStart)
+        {
+                // Figure out whether this cookie ended with a ";" or not...
+                std::string::size_type last_char = mCookie.find_last_not_of(" ");
+                if((last_char != std::string::npos) && (mCookie[last_char] != ';'))
+                {
+                        mCookie += ";";
+                }
+                
+                mCookie += " path=";
+                mPathStart = mCookie.size();
+                mCookie += "/";
+                mPathEnd = mCookie.size();
+                
+                LL_DEBUGS("CookieStoreParse") << "added path (" << mPathStart << " to " << mPathEnd << "), new cookie is: " << mCookie << LL_ENDL;
+        }
+        
+        
+        return true;
+}
+
+std::string::size_type LLPluginCookieStore::Cookie::findFieldEnd(std::string::size_type start, std::string::size_type end)
+{
+        std::string::size_type result = start;
+        
+        if(end == std::string::npos)
+                end = mCookie.size();
+        
+        bool in_quotes = false;
+        for(; (result < end); result++)
+        {
+                switch(mCookie[result])
+                {
+                        case '\\':
+                                if(in_quotes)
+                                        result++; // The next character is backslash-quoted.  Skip over it.
+                        break;
+                        case '"':
+                                in_quotes = !in_quotes;
+                        break;
+                        case ';':
+                                if(!in_quotes)
+                                        return result;
+                        break;
+                }               
+        }
+        
+        // If we got here, no ';' was found.
+        return end;
+}
+
+bool LLPluginCookieStore::Cookie::matchName(std::string::size_type start, std::string::size_type end, const char *name)
+{
+        // NOTE: this assumes 'name' is already in lowercase.  The code which uses it should be able to arrange this...
+        
+        while((start < end) && (*name != '\0'))
+        {
+                if(tolower(mCookie[start]) != *name)
+                        return false;
+                        
+                start++;
+                name++;
+        }
+        
+        // iff both strings hit the end at the same time, they're equal.
+        return ((start == end) && (*name == '\0'));
+}
+
+std::string LLPluginCookieStore::getAllCookies()
+{
+        std::stringstream result;
+        writeAllCookies(result);
+        return result.str();
+}
+
+void LLPluginCookieStore::writeAllCookies(std::ostream& s)
+{
+        cookie_map_t::iterator iter;
+        for(iter = mCookies.begin(); iter != mCookies.end(); iter++)
+        {
+                // Don't return expired cookies
+                if(!iter->second->isDead())
+                {
+                        s << (iter->second->getCookie()) << "\n";
+                }
+        }
+
+}
+
+std::string LLPluginCookieStore::getPersistentCookies()
+{
+        std::stringstream result;
+        writePersistentCookies(result);
+        return result.str();
+}
+
+void LLPluginCookieStore::writePersistentCookies(std::ostream& s)
+{
+        cookie_map_t::iterator iter;
+        for(iter = mCookies.begin(); iter != mCookies.end(); iter++)
+        {
+                // Don't return expired cookies or session cookies
+                if(!iter->second->isDead() && !iter->second->isSessionCookie())
+                {
+                        s << iter->second->getCookie() << "\n";
+                }
+        }
+}
+
+std::string LLPluginCookieStore::getChangedCookies(bool clear_changed)
+{
+        std::stringstream result;
+        writeChangedCookies(result, clear_changed);
+        
+        return result.str();
+}
+
+void LLPluginCookieStore::writeChangedCookies(std::ostream& s, bool clear_changed)
+{
+        if(mHasChangedCookies)
+        {
+                lldebugs << "returning changed cookies: " << llendl;
+                cookie_map_t::iterator iter;
+                for(iter = mCookies.begin(); iter != mCookies.end(); )
+                {
+                        cookie_map_t::iterator next = iter;
+                        next++;
+                        
+                        // Only return cookies marked as "changed"
+                        if(iter->second->isChanged())
+                        {
+                                s << iter->second->getCookie() << "\n";
+
+                                lldebugs << "    " << iter->second->getCookie() << llendl;
+
+                                // If requested, clear the changed mark
+                                if(clear_changed)
+                                {
+                                        if(iter->second->isDead())
+                                        {
+                                                // If this cookie was previously marked dead, it needs to be removed entirely.  
+                                                delete iter->second;
+                                                mCookies.erase(iter);
+                                        }
+                                        else
+                                        {
+                                                // Not dead, just mark as not changed.
+                                                iter->second->setChanged(false);
+                                        }
+                                }
+                        }
+                        
+                        iter = next;
+                }
+        }
+        
+        if(clear_changed)
+                mHasChangedCookies = false;
+}
+
+void LLPluginCookieStore::setAllCookies(const std::string &cookies, bool mark_changed)
+{
+        clearCookies();
+        setCookies(cookies, mark_changed);
+}
+
+void LLPluginCookieStore::readAllCookies(std::istream& s, bool mark_changed)
+{
+        clearCookies();
+        readCookies(s, mark_changed);
+}
+        
+void LLPluginCookieStore::setCookies(const std::string &cookies, bool mark_changed)
+{
+        std::string::size_type start = 0;
+
+        while(start != std::string::npos)
+        {
+                std::string::size_type end = cookies.find_first_of("\r\n", start);
+                if(end > start)
+                {
+                        // The line is non-empty.  Try to create a cookie from it.
+                        setOneCookie(cookies, start, end, mark_changed);
+                }
+                start = cookies.find_first_not_of("\r\n ", end);
+        }
+}
+
+void LLPluginCookieStore::setCookiesFromHost(const std::string &cookies, const std::string &host, bool mark_changed)
+{
+        std::string::size_type start = 0;
+
+        while(start != std::string::npos)
+        {
+                std::string::size_type end = cookies.find_first_of("\r\n", start);
+                if(end > start)
+                {
+                        // The line is non-empty.  Try to create a cookie from it.
+                        setOneCookie(cookies, start, end, mark_changed, host);
+                }
+                start = cookies.find_first_not_of("\r\n ", end);
+        }
+}
+                        
+void LLPluginCookieStore::readCookies(std::istream& s, bool mark_changed)
+{
+        std::string line;
+        while(s.good() && !s.eof())
+        {
+                std::getline(s, line);
+                if(!line.empty())
+                {
+                        // Try to create a cookie from this line.
+                        setOneCookie(line, 0, std::string::npos, mark_changed);
+                }
+        }
+}
+
+std::string LLPluginCookieStore::quoteString(const std::string &s)
+{
+        std::stringstream result;
+        
+        result << '"';
+        
+        for(std::string::size_type i = 0; i < s.size(); ++i)
+        {
+                char c = s[i];
+                switch(c)
+                {
+                        // All these separators need to be quoted in HTTP headers, according to section 2.2 of rfc 2616:
+                        case '(': case ')': case '<': case '>': case '@':
+                        case ',': case ';': case ':': case '\\': case '"':
+                        case '/': case '[': case ']': case '?': case '=':
+                        case '{': case '}':     case ' ': case '\t':
+                                result << '\\';
+                        break;
+                }
+                
+                result << c;
+        }
+        
+        result << '"';
+        
+        return result.str();
+}
+
+std::string LLPluginCookieStore::unquoteString(const std::string &s)
+{
+        std::stringstream result;
+        
+        bool in_quotes = false;
+        
+        for(std::string::size_type i = 0; i < s.size(); ++i)
+        {
+                char c = s[i];
+                switch(c)
+                {
+                        case '\\':
+                                if(in_quotes)
+                                {
+                                        // The next character is backslash-quoted.  Pass it through untouched.
+                                        ++i; 
+                                        if(i < s.size())
+                                        {
+                                                result << s[i];
+                                        }
+                                        continue;
+                                }
+                        break;
+                        case '"':
+                                in_quotes = !in_quotes;
+                                continue;
+                        break;
+                }
+                
+                result << c;
+        }
+        
+        return result.str();
+}
+
+// The flow for deleting a cookie is non-obvious enough that I should call it out here...
+// Deleting a cookie is done by setting a cookie with the same name, path, and domain, but with an expire timestamp in the past.
+// (This is exactly how a web server tells a browser to delete a cookie.)
+// When deleting with mark_changed set to true, this replaces the existing cookie in the list with an entry that's marked both dead and changed.
+// Some time later when writeChangedCookies() is called with clear_changed set to true, the dead cookie is deleted from the list after being returned, so that the
+// delete operation (in the form of the expired cookie) is passed along.
+void LLPluginCookieStore::setOneCookie(const std::string &s, std::string::size_type cookie_start, std::string::size_type cookie_end, bool mark_changed, const std::string &host)
+{
+        Cookie *cookie = Cookie::createFromString(s, cookie_start, cookie_end, host);
+        if(cookie)
+        {
+                LL_DEBUGS("CookieStoreUpdate") << "setting cookie: " << cookie->getCookie() << LL_ENDL;
+                
+                // Create a key for this cookie
+                std::string key = cookie->getKey();
+                
+                // Check to see whether this cookie should have expired
+                if(!cookie->isSessionCookie() && (cookie->getDate() < LLDate::now()))
+                {
+                        // This cookie has expired.
+                        if(mark_changed)
+                        {
+                                // If we're marking cookies as changed, we should keep it anyway since we'll need to send it out with deltas.
+                                cookie->setDead(true);
+                                LL_DEBUGS("CookieStoreUpdate") << "    marking dead" << LL_ENDL;
+                        }
+                        else
+                        {
+                                // If we're not marking cookies as changed, we don't need to keep this cookie at all.
+                                // If the cookie was already in the list, delete it.
+                                removeCookie(key);
+
+                                delete cookie;
+                                cookie = NULL;
+
+                                LL_DEBUGS("CookieStoreUpdate") << "    removing" << LL_ENDL;
+                        }
+                }
+                
+                if(cookie)
+                {
+                        // If it already exists in the map, replace it.
+                        cookie_map_t::iterator iter = mCookies.find(key);
+                        if(iter != mCookies.end())
+                        {
+                                if(iter->second->getCookie() == cookie->getCookie())
+                                {
+                                        // The new cookie is identical to the old -- don't mark as changed.
+                                        // Just leave the old one in the map.
+                                        delete cookie;
+                                        cookie = NULL;
+
+                                        LL_DEBUGS("CookieStoreUpdate") << "    unchanged" << LL_ENDL;
+                                }
+                                else
+                                {
+                                        // A matching cookie was already in the map.  Replace it.
+                                        delete iter->second;
+                                        iter->second = cookie;
+                                        
+                                        cookie->setChanged(mark_changed);
+                                        if(mark_changed)
+                                                mHasChangedCookies = true;
+
+                                        LL_DEBUGS("CookieStoreUpdate") << "    replacing" << LL_ENDL;
+                                }
+                        }
+                        else
+                        {
+                                // The cookie wasn't in the map.  Insert it.
+                                mCookies.insert(std::make_pair(key, cookie));
+                                
+                                cookie->setChanged(mark_changed);
+                                if(mark_changed)
+                                        mHasChangedCookies = true;
+
+                                LL_DEBUGS("CookieStoreUpdate") << "    adding" << LL_ENDL;
+                        }
+                }
+        }
+        else
+        {
+                LL_WARNS("CookieStoreUpdate") << "failed to parse cookie: " << s.substr(cookie_start, cookie_end - cookie_start) << LL_ENDL;
+        }
+
+}
+
+void LLPluginCookieStore::clearCookies()
+{
+        while(!mCookies.empty())
+        {
+                cookie_map_t::iterator iter = mCookies.begin();
+                delete iter->second;
+                mCookies.erase(iter);
+        }
+}
+
+void LLPluginCookieStore::removeCookie(const std::string &key)
+{
+        cookie_map_t::iterator iter = mCookies.find(key);
+        if(iter != mCookies.end())
+        {
+                delete iter->second;
+                mCookies.erase(iter);
+        }
+}
+
diff --git a/linden/indra/llplugin/llplugincookiestore.h b/linden/indra/llplugin/llplugincookiestore.h
new file mode 100644
index 0000000..69f0cf1
--- /dev/null
+++ b/linden/indra/llplugin/llplugincookiestore.h
@@ -0,0 +1,127 @@
+/** 
+ * @file llplugincookiestore.h
+ * @brief LLPluginCookieStore provides central storage for http cookies used by plugins
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2010&license=viewergpl$
+ * 
+ * Copyright (c) 2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+#ifndef LL_LLPLUGINCOOKIESTORE_H
+#define LL_LLPLUGINCOOKIESTORE_H
+
+#include "lldate.h"
+#include <map>
+#include <string>
+#include <iostream>
+
+class LLPluginCookieStore
+{
+        LOG_CLASS(LLPluginCookieStore);
+public:
+        LLPluginCookieStore();
+        ~LLPluginCookieStore();
+
+        // gets all cookies currently in storage -- use when initializing a plugin
+        std::string getAllCookies();
+        void writeAllCookies(std::ostream& s);
+        
+        // gets only persistent cookies (i.e. not session cookies) -- use when writing cookies to a file
+        std::string getPersistentCookies();
+        void writePersistentCookies(std::ostream& s);
+        
+        // gets cookies which are marked as "changed" -- use when sending periodic updates to plugins
+        std::string getChangedCookies(bool clear_changed = true);
+        void writeChangedCookies(std::ostream& s, bool clear_changed = true);
+        
+        // (re)initializes internal data structures and bulk-sets cookies -- use when reading cookies from a file
+        void setAllCookies(const std::string &cookies, bool mark_changed = false);
+        void readAllCookies(std::istream& s, bool mark_changed = false);
+        
+        // sets one or more cookies (without reinitializing anything) -- use when receiving cookies from a plugin
+        void setCookies(const std::string &cookies, bool mark_changed = true);
+        void readCookies(std::istream& s, bool mark_changed = true);
+
+        // sets one or more cookies (without reinitializing anything), supplying a hostname the cookies came from -- use when setting a cookie manually
+        void setCookiesFromHost(const std::string &cookies, const std::string &host, bool mark_changed = true);
+
+        // quote or unquote a string as per the definition of 'quoted-string' in rfc2616
+        static std::string quoteString(const std::string &s);
+        static std::string unquoteString(const std::string &s);
+        
+private:
+
+        void setOneCookie(const std::string &s, std::string::size_type cookie_start, std::string::size_type cookie_end, bool mark_changed, const std::string &host = LLStringUtil::null);
+
+        class Cookie
+        {
+        public:
+                static Cookie *createFromString(const std::string &s, std::string::size_type cookie_start = 0, std::string::size_type cookie_end = std::string::npos, const std::string &host = LLStringUtil::null);
+                
+                // Construct a string from the cookie that uniquely represents it, to be used as a key in a std::map.
+                std::string getKey() const;
+                
+                const std::string &getCookie() const { return mCookie; };
+                bool isSessionCookie() const { return mDate.isNull(); };
+
+                bool isDead() const { return mDead; };
+                void setDead(bool dead) { mDead = dead; };
+                
+                bool isChanged() const { return mChanged; };
+                void setChanged(bool changed) { mChanged = changed; };
+
+                const LLDate &getDate() const { return mDate; };
+                
+        private:
+                Cookie(const std::string &s, std::string::size_type cookie_start = 0, std::string::size_type cookie_end = std::string::npos);
+                bool parse(const std::string &host);
+                std::string::size_type findFieldEnd(std::string::size_type start = 0, std::string::size_type end = std::string::npos);
+                bool matchName(std::string::size_type start, std::string::size_type end, const char *name);
+                
+                std::string mCookie;    // The full cookie, in RFC 2109 string format
+                LLDate mDate;                   // The expiration date of the cookie.  For session cookies, this will be a null date (mDate.isNull() is true).
+                // Start/end indices of various parts of the cookie string.  Stored as indices into the string to save space and time.
+                std::string::size_type mNameStart, mNameEnd;
+                std::string::size_type mValueStart, mValueEnd;
+                std::string::size_type mDomainStart, mDomainEnd;
+                std::string::size_type mPathStart, mPathEnd;
+                bool mDead;
+                bool mChanged;
+        };
+        
+        typedef std::map<std::string, Cookie*> cookie_map_t;
+        
+        cookie_map_t mCookies;
+        bool mHasChangedCookies;
+        
+        void clearCookies();
+        void removeCookie(const std::string &key);
+};
+
+#endif // LL_LLPLUGINCOOKIESTORE_H
diff --git a/linden/indra/llplugin/llplugininstance.cpp b/linden/indra/llplugin/llplugininstance.cpp
new file mode 100755
index 0000000..399f157
--- /dev/null
+++ b/linden/indra/llplugin/llplugininstance.cpp
@@ -0,0 +1,176 @@
+/** 
+ * @file llplugininstance.cpp
+ * @brief LLPluginInstance handles loading the dynamic library of a plugin and setting up its entry points for message passing.
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+/// IMPRUDENCE: this is part of the SLPlugin
+
+#include "linden_common.h"
+
+#include "llplugininstance.h"
+#include "aiaprpool.h"
+
+/** Virtual destructor. */
+LLPluginInstanceMessageListener::~LLPluginInstanceMessageListener()
+{
+}
+
+/** 
+ * TODO:DOC describe how it's used
+ */
+const char *LLPluginInstance::PLUGIN_INIT_FUNCTION_NAME = "LLPluginInitEntryPoint";
+
+/** 
+ * Constructor.
+ *
+ * @param[in] owner Plugin instance. TODO:DOC is this a good description of what "owner" is?
+ */
+LLPluginInstance::LLPluginInstance(LLPluginInstanceMessageListener *owner) :
+        mDSOHandle(NULL),
+        mPluginUserData(NULL),
+        mPluginSendMessageFunction(NULL)
+{
+        mOwner = owner;
+}
+
+/** 
+ * Destructor.
+ */
+LLPluginInstance::~LLPluginInstance()
+{
+        if(mDSOHandle != NULL)
+        {
+                apr_dso_unload(mDSOHandle);
+                mDSOHandle = NULL;
+        }
+}
+
+/** 
+ * Dynamically loads the plugin and runs the plugin's init function.
+ *
+ * @param[in] plugin_file Name of plugin dll/dylib/so. TODO:DOC is this correct? see .h
+ * @return 0 if successful, APR error code or error code from the plugin's init function on failure.
+ */
+int LLPluginInstance::load(std::string &plugin_file)
+{
+        pluginInitFunction init_function = NULL;
+        
+        int result = apr_dso_load(&mDSOHandle,
+                                          plugin_file.c_str(),
+                                          AIAPRRootPool::get()());
+        if(result != APR_SUCCESS)
+        {
+                char buf[1024];
+                apr_dso_error(mDSOHandle, buf, sizeof(buf));
+
+                LL_WARNS("PluginInstance") << "apr_dso_load of " << plugin_file << " failed with error " << result << " , additional info string: " << buf << LL_ENDL;
+
+        }
+
+        if(result == APR_SUCCESS)
+        {
+                result = apr_dso_sym((apr_dso_handle_sym_t*)&init_function,
+                                                 mDSOHandle,
+                                                 PLUGIN_INIT_FUNCTION_NAME);
+
+                if(result != APR_SUCCESS)
+                {
+                        LL_WARNS("PluginInstance") << "apr_dso_sym failed with error " << result << LL_ENDL;
+                }
+        }
+
+        if(result == APR_SUCCESS)
+        {
+                result = init_function(staticReceiveMessage, (void*)this, &mPluginSendMessageFunction, &mPluginUserData);
+
+                if(result != APR_SUCCESS)
+                {
+                        LL_WARNS("PluginInstance") << "call to init function failed with error " << result << LL_ENDL;
+                }
+        }
+
+        return (int)result;
+}
+
+/** 
+ * Sends a message to the plugin.
+ *
+ * @param[in] message Message
+ */
+void LLPluginInstance::sendMessage(const std::string &message)
+{
+        if(mPluginSendMessageFunction)
+        {
+                LL_DEBUGS("PluginInstance") << "sending message to plugin: \"" << message << "\"" << LL_ENDL;
+                mPluginSendMessageFunction(message.c_str(), &mPluginUserData);
+        }
+        else
+        {
+                LL_WARNS("PluginInstance") << "dropping message: \"" << message << "\"" << LL_ENDL;
+        }
+}
+
+/**
+ * Idle. TODO:DOC what's the purpose of this?
+ *
+ */
+void LLPluginInstance::idle(void)
+{
+}
+
+// static
+void LLPluginInstance::staticReceiveMessage(const char *message_string, void **user_data)
+{
+        // TODO: validate that the user_data argument is still a valid LLPluginInstance pointer
+        // we could also use a key that's looked up in a map (instead of a direct pointer) for safety, but that's probably overkill
+        LLPluginInstance *self = (LLPluginInstance*)*user_data;
+        self->receiveMessage(message_string);
+}
+
+/**
+ * Plugin receives message from plugin loader shell.
+ *
+ * @param[in] message_string Message
+ */
+void LLPluginInstance::receiveMessage(const char *message_string)
+{
+        if(mOwner)
+        {
+                LL_DEBUGS("PluginInstance") << "processing incoming message: \"" << message_string << "\"" << LL_ENDL;
+                mOwner->receivePluginMessage(message_string);
+        }
+        else
+        {
+                LL_WARNS("PluginInstance") << "dropping incoming message: \"" << message_string << "\"" << LL_ENDL;
+        }
+}
diff --git a/linden/indra/llplugin/llplugininstance.h b/linden/indra/llplugin/llplugininstance.h
new file mode 100755
index 0000000..9cf6075
--- /dev/null
+++ b/linden/indra/llplugin/llplugininstance.h
@@ -0,0 +1,106 @@
+/** 
+ * @file llplugininstance.h
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+#ifndef LL_LLPLUGININSTANCE_H
+#define LL_LLPLUGININSTANCE_H
+
+#include "llstring.h"
+#include "llapr.h"
+
+#include "apr_dso.h"
+
+/**
+ * @brief LLPluginInstanceMessageListener receives messages sent from the plugin loader shell to the plugin.
+ */
+class LLPluginInstanceMessageListener
+{
+public:
+        virtual ~LLPluginInstanceMessageListener();
+   /** Plugin receives message from plugin loader shell. */
+        virtual void receivePluginMessage(const std::string &message) = 0;
+};
+
+/**
+ * @brief LLPluginInstance handles loading the dynamic library of a plugin and setting up its entry points for message passing.
+ */
+class LLPluginInstance
+{
+        LOG_CLASS(LLPluginInstance);
+public:
+        LLPluginInstance(LLPluginInstanceMessageListener *owner);
+        virtual ~LLPluginInstance();
+        
+        // Load a plugin dll/dylib/so
+        // Returns 0 if successful, APR error code or error code returned from the plugin's init function on failure.
+        int load(std::string &plugin_file);
+        
+        // Sends a message to the plugin.
+        void sendMessage(const std::string &message);
+        
+   // TODO:DOC is this comment obsolete? can't find "send_count" anywhere in indra tree.
+        // send_count is the maximum number of message to process from the send queue.  If negative, it will drain the queue completely.
+        // The receive queue is always drained completely.
+        // Returns the total number of messages processed from both queues.
+        void idle(void);
+        
+        /** The signature of the function for sending a message from plugin to plugin loader shell.
+    *
+         * @param[in] message_string Null-terminated C string 
+    * @param[in] user_data The opaque reference that the callee supplied during setup.
+    */
+        typedef void (*sendMessageFunction) (const char *message_string, void **user_data);
+
+        /** The signature of the plugin init function. TODO:DOC check direction (pluging loader shell to plugin?)
+    *
+    * @param[in] host_user_data Data from plugin loader shell.
+    * @param[in] plugin_send_function Function for sending from the plugin loader shell to plugin.
+    */
+        typedef int (*pluginInitFunction) (sendMessageFunction host_send_func, void *host_user_data, sendMessageFunction *plugin_send_func, void **plugin_user_data);
+        
+   /** Name of plugin init function */
+        static const char *PLUGIN_INIT_FUNCTION_NAME;
+        
+private:
+        static void staticReceiveMessage(const char *message_string, void **user_data);
+        void receiveMessage(const char *message_string);
+
+        apr_dso_handle_t *mDSOHandle;
+        
+        void *mPluginUserData;
+        sendMessageFunction mPluginSendMessageFunction;
+        
+        LLPluginInstanceMessageListener *mOwner;
+};
+
+#endif // LL_LLPLUGININSTANCE_H
diff --git a/linden/indra/llplugin/llpluginmessage.cpp b/linden/indra/llplugin/llpluginmessage.cpp
new file mode 100755
index 0000000..0810a04
--- /dev/null
+++ b/linden/indra/llplugin/llpluginmessage.cpp
@@ -0,0 +1,447 @@
+/** 
+ * @file llpluginmessage.cpp
+ * @brief LLPluginMessage encapsulates the serialization/deserialization of messages passed to and from plugins.
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+/// IMPRUDENCE: this is part of the viewer and the SLPlugin and the libmedia_plugin_* libraries
+
+#include "linden_common.h"
+
+#include "llpluginmessage.h"
+#include "llsdserialize.h"
+#include "u64.h"
+
+/**
+ * Constructor.
+ */
+LLPluginMessage::LLPluginMessage()
+{
+}
+
+/**
+ * Constructor.
+ *
+ * @param[in] p Existing message
+ */
+LLPluginMessage::LLPluginMessage(const LLPluginMessage &p)
+{
+        mMessage = p.mMessage;
+}
+
+/**
+ * Constructor.
+ *
+ * @param[in] message_class Message class
+ * @param[in] message_name Message name
+ */
+LLPluginMessage::LLPluginMessage(const std::string &message_class, const std::string &message_name)
+{
+        setMessage(message_class, message_name);
+}
+
+
+/**
+ * Destructor.
+ */
+LLPluginMessage::~LLPluginMessage()
+{
+}
+
+/**
+ * Reset all internal state.
+ */
+void LLPluginMessage::clear()
+{
+        mMessage = LLSD::emptyMap();
+        mMessage["params"] = LLSD::emptyMap();
+}
+
+/**
+ * Sets the message class and name. Also has the side-effect of clearing any key-value pairs in the message.
+ *
+ * @param[in] message_class Message class
+ * @param[in] message_name Message name
+ */
+void LLPluginMessage::setMessage(const std::string &message_class, const std::string &message_name)
+{
+        clear();
+        mMessage["class"] = message_class;
+        mMessage["name"] = message_name;
+}
+
+/**
+ * Sets a key/value pair in the message, where the value is a string.
+ *
+ * @param[in] key Key
+ * @param[in] value String value
+ */
+void LLPluginMessage::setValue(const std::string &key, const std::string &value)
+{
+        mMessage["params"][key] = value;
+}
+
+/**
+ * Sets a key/value pair in the message, where the value is LLSD.
+ *
+ * @param[in] key Key
+ * @param[in] value LLSD value
+ */
+void LLPluginMessage::setValueLLSD(const std::string &key, const LLSD &value)
+{
+        mMessage["params"][key] = value;
+}
+
+/**
+ * Sets a key/value pair in the message, where the value is signed 32-bit.
+ *
+ * @param[in] key Key
+ * @param[in] value 32-bit signed value
+ */
+void LLPluginMessage::setValueS32(const std::string &key, S32 value)
+{
+        mMessage["params"][key] = value;
+}
+
+/**
+ * Sets a key/value pair in the message, where the value is unsigned 32-bit. The value is stored as a string beginning with "0x".
+ *
+ * @param[in] key Key
+ * @param[in] value 32-bit unsigned value
+ */
+void LLPluginMessage::setValueU32(const std::string &key, U32 value)
+{
+        std::stringstream temp;
+        temp << "0x" << std::hex << value;
+        setValue(key, temp.str());
+}
+
+/**
+ * Sets a key/value pair in the message, where the value is a bool.
+ *
+ * @param[in] key Key
+ * @param[in] value Boolean value
+ */
+void LLPluginMessage::setValueBoolean(const std::string &key, bool value)
+{
+        mMessage["params"][key] = value;
+}
+
+/**
+ * Sets a key/value pair in the message, where the value is a double.
+ *
+ * @param[in] key Key
+ * @param[in] value Boolean value
+ */
+void LLPluginMessage::setValueReal(const std::string &key, F64 value)
+{
+        mMessage["params"][key] = value;
+}
+
+/**
+ * Sets a key/value pair in the message, where the value is a pointer. The pointer is stored as a string.
+ *
+ * @param[in] key Key
+ * @param[in] value Pointer value
+ */
+void LLPluginMessage::setValuePointer(const std::string &key, void* value)
+{
+        std::stringstream temp;
+        // iostreams should output pointer values in hex with an initial 0x by default.
+        temp << value;
+        setValue(key, temp.str());
+}
+
+/**
+ * Gets the message class.
+ *
+ * @return Message class
+ */
+std::string LLPluginMessage::getClass(void) const
+{
+        return mMessage["class"];
+}
+
+/**
+ * Gets the message name.
+ *
+ * @return Message name
+ */
+std::string LLPluginMessage::getName(void) const
+{
+        return mMessage["name"];
+}
+
+/**
+ *      Returns true if the specified key exists in this message (useful for optional parameters).
+ *
+ * @param[in] key Key
+ *
+ * @return True if key exists, false otherwise.
+ */
+bool LLPluginMessage::hasValue(const std::string &key) const
+{
+        bool result = false;
+        
+        if(mMessage["params"].has(key))
+        {
+                result = true;
+        }
+        
+        return result;
+}
+
+/**
+ *      Gets the value of a key as a string. If the key does not exist, an empty string will be returned.
+ *
+ * @param[in] key Key
+ *
+ * @return String value of key if key exists, empty string if key does not exist.
+ */
+std::string LLPluginMessage::getValue(const std::string &key) const
+{
+        std::string result;
+        
+        if(mMessage["params"].has(key))
+        {
+                result = mMessage["params"][key].asString();
+        }
+        
+        return result;
+}
+
+/**
+ *      Gets the value of a key as LLSD. If the key does not exist, a null LLSD will be returned.
+ *
+ * @param[in] key Key
+ *
+ * @return LLSD value of key if key exists, null LLSD if key does not exist.
+ */
+LLSD LLPluginMessage::getValueLLSD(const std::string &key) const
+{
+        LLSD result;
+
+        if(mMessage["params"].has(key))
+        {
+                result = mMessage["params"][key];
+        }
+        
+        return result;
+}
+
+/**
+ *      Gets the value of a key as signed 32-bit int. If the key does not exist, 0 will be returned.
+ *
+ * @param[in] key Key
+ *
+ * @return Signed 32-bit int value of key if key exists, 0 if key does not exist.
+ */
+S32 LLPluginMessage::getValueS32(const std::string &key) const
+{
+        S32 result = 0;
+
+        if(mMessage["params"].has(key))
+        {
+                result = mMessage["params"][key].asInteger();
+        }
+        
+        return result;
+}
+
+/**
+ *      Gets the value of a key as unsigned 32-bit int. If the key does not exist, 0 will be returned.
+ *
+ * @param[in] key Key
+ *
+ * @return Unsigned 32-bit int value of key if key exists, 0 if key does not exist.
+ */
+U32 LLPluginMessage::getValueU32(const std::string &key) const
+{
+        U32 result = 0;
+
+        if(mMessage["params"].has(key))
+        {
+                std::string value = mMessage["params"][key].asString();
+                
+                result = (U32)strtoul(value.c_str(), NULL, 16);
+        }
+        
+        return result;
+}
+
+/**
+ *      Gets the value of a key as a bool. If the key does not exist, false will be returned.
+ *
+ * @param[in] key Key
+ *
+ * @return Boolean value of key if it exists, false otherwise.
+ */
+bool LLPluginMessage::getValueBoolean(const std::string &key) const
+{
+        bool result = false;
+
+        if(mMessage["params"].has(key))
+        {
+                result = mMessage["params"][key].asBoolean();
+        }
+        
+        return result;
+}
+
+/**
+ *      Gets the value of a key as a double. If the key does not exist, 0 will be returned.
+ *
+ * @param[in] key Key
+ *
+ * @return Value as a double if key exists, 0 otherwise.
+ */
+F64 LLPluginMessage::getValueReal(const std::string &key) const
+{
+        F64 result = 0.0f;
+
+        if(mMessage["params"].has(key))
+        {
+                result = mMessage["params"][key].asReal();
+        }
+        
+        return result;
+}
+
+/**
+ *      Gets the value of a key as a pointer. If the key does not exist, NULL will be returned.
+ *
+ * @param[in] key Key
+ *
+ * @return Pointer value if key exists, NULL otherwise.
+ */
+void* LLPluginMessage::getValuePointer(const std::string &key) const
+{
+        void* result = NULL;
+
+        if(mMessage["params"].has(key))
+        {
+                std::string value = mMessage["params"][key].asString();
+                
+                result = (void*)llstrtou64(value.c_str(), NULL, 16);
+        }
+        
+        return result;
+}
+
+/**
+ *      Flatten the message into a string.
+ *
+ * @return Message as a string.
+ */
+std::string LLPluginMessage::generate(void) const
+{
+        std::ostringstream result;
+        
+        // Pretty XML may be slightly easier to deal with while debugging...
+//      LLSDSerialize::toXML(mMessage, result);
+        LLSDSerialize::toPrettyXML(mMessage, result);
+        
+        return result.str();
+}
+
+/**
+ *      Parse an incoming message into component parts. Clears all existing state before starting the parse.
+ *
+ * @return Returns -1 on failure, otherwise returns the number of key/value pairs in the incoming message.
+ */
+int LLPluginMessage::parse(const std::string &message)
+{
+        // clear any previous state
+        clear();
+
+        std::istringstream input(message);
+        
+        S32 parse_result = LLSDSerialize::fromXML(mMessage, input);
+        
+        return (int)parse_result;
+}
+
+
+/**
+ * Destructor
+ */
+LLPluginMessageListener::~LLPluginMessageListener()
+{
+        // TODO: should listeners have a way to ensure they're removed from dispatcher lists when deleted?
+}
+
+
+/**
+ * Destructor
+ */
+LLPluginMessageDispatcher::~LLPluginMessageDispatcher()
+{
+        
+}
+        
+/**
+ * Add a message listener. TODO:DOC need more info on what uses this. when are multiple listeners needed?
+ *
+ * @param[in] listener Message listener
+ */
+void LLPluginMessageDispatcher::addPluginMessageListener(LLPluginMessageListener *listener)
+{
+        mListeners.insert(listener);
+}
+
+/**
+ * Remove a message listener.
+ *
+ * @param[in] listener Message listener
+ */
+void LLPluginMessageDispatcher::removePluginMessageListener(LLPluginMessageListener *listener)
+{
+        mListeners.erase(listener);
+}
+
+/**
+ * Distribute a message to all message listeners.
+ *
+ * @param[in] message Message
+ */
+void LLPluginMessageDispatcher::dispatchPluginMessage(const LLPluginMessage &message)
+{
+        for (listener_set_t::iterator it = mListeners.begin();
+                it != mListeners.end();
+                )
+        {
+                LLPluginMessageListener* listener = *it;
+                listener->receivePluginMessage(message);
+                // In case something deleted an entry.
+                it = mListeners.upper_bound(listener);
+        }
+}
diff --git a/linden/indra/llplugin/llpluginmessage.h b/linden/indra/llplugin/llpluginmessage.h
new file mode 100755
index 0000000..fe504c8
--- /dev/null
+++ b/linden/indra/llplugin/llpluginmessage.h
@@ -0,0 +1,144 @@
+/** 
+ * @file llpluginmessage.h
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+#ifndef LL_LLPLUGINMESSAGE_H
+#define LL_LLPLUGINMESSAGE_H
+
+#include "llsd.h"
+
+/**
+ * @brief LLPluginMessage encapsulates the serialization/deserialization of messages passed to and from plugins.
+ */
+class LLPluginMessage
+{
+        LOG_CLASS(LLPluginMessage);
+public:
+        LLPluginMessage();
+        LLPluginMessage(const LLPluginMessage &p);
+        LLPluginMessage(const std::string &message_class, const std::string &message_name);
+        ~LLPluginMessage();
+        
+        // reset all internal state
+        void clear(void);
+        
+        // Sets the message class and name
+        // Also has the side-effect of clearing any key/value pairs in the message.
+        void setMessage(const std::string &message_class, const std::string &message_name);
+        
+        // Sets a key/value pair in the message
+        void setValue(const std::string &key, const std::string &value);
+        void setValueLLSD(const std::string &key, const LLSD &value);
+        void setValueS32(const std::string &key, S32 value);
+        void setValueU32(const std::string &key, U32 value);
+        void setValueBoolean(const std::string &key, bool value);
+        void setValueReal(const std::string &key, F64 value);
+        void setValuePointer(const std::string &key, void *value);
+        
+        std::string getClass(void) const;
+        std::string getName(void) const;
+        
+        // Returns true if the specified key exists in this message (useful for optional parameters)
+        bool hasValue(const std::string &key) const;
+        
+        // get the value of a particular key as a string.  If the key doesn't exist in the message, an empty string will be returned.
+        std::string getValue(const std::string &key) const;
+
+        // get the value of a particular key as LLSD.  If the key doesn't exist in the message, a null LLSD will be returned.
+        LLSD getValueLLSD(const std::string &key) const;
+        
+        // get the value of a key as a S32.  If the value wasn't set as a S32, behavior is undefined.
+        S32 getValueS32(const std::string &key) const;
+        
+        // get the value of a key as a U32.  Since there isn't an LLSD type for this, we use a hexadecimal string instead.
+        U32 getValueU32(const std::string &key) const;
+
+        // get the value of a key as a Boolean.
+        bool getValueBoolean(const std::string &key) const;
+
+        // get the value of a key as a float.
+        F64 getValueReal(const std::string &key) const;
+
+        // get the value of a key as a pointer.
+        void* getValuePointer(const std::string &key) const;
+
+        // Flatten the message into a string
+        std::string generate(void) const;
+
+        // Parse an incoming message into component parts
+        // (this clears out all existing state before starting the parse)
+        // Returns -1 on failure, otherwise returns the number of key/value pairs in the message.
+        int parse(const std::string &message);
+        
+        
+private:
+        
+        LLSD mMessage;
+
+};
+
+/**
+ * @brief Listener for plugin messages.
+ */
+class LLPluginMessageListener
+{
+public:
+        virtual ~LLPluginMessageListener();
+   /** Plugin receives message from plugin loader shell. */
+        virtual void receivePluginMessage(const LLPluginMessage &message) = 0;
+        
+};
+
+/**
+ * @brief Dispatcher for plugin messages.
+ *
+ * Manages the set of plugin message listeners and distributes messages to plugin message listeners.
+ */
+class LLPluginMessageDispatcher
+{
+public:
+        virtual ~LLPluginMessageDispatcher();
+        
+        void addPluginMessageListener(LLPluginMessageListener *);
+        void removePluginMessageListener(LLPluginMessageListener *);
+protected:
+        void dispatchPluginMessage(const LLPluginMessage &message);
+
+   /** A set of message listeners. */
+        typedef std::set<LLPluginMessageListener*> listener_set_t;
+   /** The set of message listeners. */
+        listener_set_t mListeners;
+};
+
+
+#endif // LL_LLPLUGINMESSAGE_H
diff --git a/linden/indra/llplugin/llpluginmessageclasses.h b/linden/indra/llplugin/llpluginmessageclasses.h
new file mode 100755
index 0000000..8812a16
--- /dev/null
+++ b/linden/indra/llplugin/llpluginmessageclasses.h
@@ -0,0 +1,60 @@
+/** 
+ * @file llpluginmessageclasses.h
+ * @brief This file defines the versions of existing message classes for LLPluginMessage.
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+#ifndef LL_LLPLUGINMESSAGECLASSES_H
+#define LL_LLPLUGINMESSAGECLASSES_H
+
+// Version strings for each plugin message class.  
+// Backwards-compatible changes (i.e. changes which only add new messges) should increment the minor version (i.e. "1.0" -> "1.1").
+// Non-backwards-compatible changes (which delete messages or change their semantics) should increment the major version (i.e. "1.1" -> "2.0").
+// Plugins will supply the set of message classes they understand, with version numbers, as part of their init_response message.
+// The contents and semantics of the base:init message must NEVER change in a non-backwards-compatible way, as a special case.
+
+#define LLPLUGIN_MESSAGE_CLASS_INTERNAL "internal"
+#define LLPLUGIN_MESSAGE_CLASS_INTERNAL_VERSION "1.0"
+
+#define LLPLUGIN_MESSAGE_CLASS_BASE "base"
+#define LLPLUGIN_MESSAGE_CLASS_BASE_VERSION "1.0"
+
+#define LLPLUGIN_MESSAGE_CLASS_MEDIA "media"
+#define LLPLUGIN_MESSAGE_CLASS_MEDIA_VERSION "1.0"
+
+#define LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER "media_browser"
+#define LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER_VERSION "1.0"
+
+#define LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME "media_time"
+#define LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME_VERSION "1.0"
+
+#endif // LL_LLPLUGINMESSAGECLASSES_H
diff --git a/linden/indra/llplugin/llpluginmessagepipe.cpp b/linden/indra/llplugin/llpluginmessagepipe.cpp
new file mode 100755
index 0000000..2cad188
--- /dev/null
+++ b/linden/indra/llplugin/llpluginmessagepipe.cpp
@@ -0,0 +1,387 @@
+/** 
+ * @file llpluginmessagepipe.cpp
+ * @brief Classes that implement connections from the plugin system to pipes/pumps.
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+/// IMPRUDENCE: this is part of the viewer and the SLPlugin
+
+#include "linden_common.h"
+
+#include "llpluginmessagepipe.h"
+#include "llbufferstream.h"
+
+#include "llapr.h"
+
+static const char MESSAGE_DELIMITER = '\0';
+
+LLPluginMessagePipeOwner::LLPluginMessagePipeOwner() :
+        mMessagePipe(NULL),
+        mSocketError(APR_SUCCESS)
+{
+}
+
+// virtual 
+LLPluginMessagePipeOwner::~LLPluginMessagePipeOwner()
+{
+        killMessagePipe();
+}
+
+// virtual 
+apr_status_t LLPluginMessagePipeOwner::socketError(apr_status_t error)
+{ 
+        mSocketError = error;
+        return error; 
+};
+
+//virtual 
+void LLPluginMessagePipeOwner::setMessagePipe(LLPluginMessagePipe *read_pipe)
+{
+        // Save a reference to this pipe
+        mMessagePipe = read_pipe;
+}
+
+bool LLPluginMessagePipeOwner::canSendMessage(void)
+{
+        return (mMessagePipe != NULL);
+}
+
+bool LLPluginMessagePipeOwner::writeMessageRaw(const std::string &message)
+{
+        bool result = true;
+        if(mMessagePipe != NULL)
+        {
+                result = mMessagePipe->addMessage(message);
+        }
+        else
+        {
+                LL_WARNS("PluginPipe") << "dropping message: " << message << LL_ENDL;
+                result = false;
+        }
+
+        return result;
+}
+
+void LLPluginMessagePipeOwner::killMessagePipe(void)
+{
+        if(mMessagePipe != NULL)
+        {
+                delete mMessagePipe;
+                mMessagePipe = NULL;
+        }
+}
+
+LLPluginMessagePipe::LLPluginMessagePipe(LLPluginMessagePipeOwner *owner, LLSocket::ptr_t socket):
+        mOwner(owner),
+        mSocket(socket)
+{
+        
+        mOwner->setMessagePipe(this);
+}
+
+LLPluginMessagePipe::~LLPluginMessagePipe()
+{
+        if(mOwner != NULL)
+        {
+                mOwner->setMessagePipe(NULL);
+        }
+}
+
+bool LLPluginMessagePipe::addMessage(const std::string &message)
+{
+        // queue the message for later output
+        LLMutexLock lock(&mOutputMutex);
+        mOutput += message;
+        mOutput += MESSAGE_DELIMITER;   // message separator
+        
+        return true;
+}
+
+void LLPluginMessagePipe::clearOwner(void)
+{
+        // The owner is done with this pipe.  The next call to process_impl should send any remaining data and exit.
+        mOwner = NULL;
+}
+
+void LLPluginMessagePipe::setSocketTimeout(apr_interval_time_t timeout_usec)
+{
+        // We never want to sleep forever, so force negative timeouts to become non-blocking.
+
+        // according to this page: http://dev.ariel-networks.com/apr/apr-tutorial/html/apr-tutorial-13.html
+        // blocking/non-blocking with apr sockets is somewhat non-portable.
+        
+        if(timeout_usec <= 0)
+        {
+                // Make the socket non-blocking
+                apr_socket_opt_set(mSocket->getSocket(), APR_SO_NONBLOCK, 1);
+                apr_socket_timeout_set(mSocket->getSocket(), 0);
+        }
+        else
+        {
+                // Make the socket blocking-with-timeout
+                apr_socket_opt_set(mSocket->getSocket(), APR_SO_NONBLOCK, 1);
+                apr_socket_timeout_set(mSocket->getSocket(), timeout_usec);
+        }
+}
+
+bool LLPluginMessagePipe::pump(F64 timeout)
+{
+        bool result = pumpOutput();
+        
+        if(result)
+        {
+                result = pumpInput(timeout);
+        }
+        
+        return result;
+}
+
+bool LLPluginMessagePipe::pumpOutput()
+{
+        bool result = true;
+        
+        if(mSocket)
+        {
+                apr_status_t status;
+                apr_size_t size;
+                
+                LLMutexLock lock(&mOutputMutex);
+                if(!mOutput.empty())
+                {
+                        // write any outgoing messages
+                        size = (apr_size_t)mOutput.size();
+
+                        setSocketTimeout(0);
+
+//                      LL_INFOS("PluginPipe") << "before apr_socket_send, size = " << size << LL_ENDL;
+
+                        status = apr_socket_send(
+                                        mSocket->getSocket(),
+                                        (const char*)mOutput.data(),
+                                        &size);
+
+//                      LL_INFOS("PluginPipe") << "after apr_socket_send, size = " << size << LL_ENDL;
+
+                        if(status == APR_SUCCESS)
+                        {
+                                // success
+                                mOutput = mOutput.substr(size);
+                        }
+                        else if(APR_STATUS_IS_EAGAIN(status))
+                        {
+                                // Socket buffer is full... 
+                                // remove the written part from the buffer and try again later.
+                                mOutput = mOutput.substr(size);
+                        }
+                        else if(APR_STATUS_IS_EOF(status))
+                        {
+                                // This is what we normally expect when a plugin exits.
+                                llinfos << "Got EOF from plugin socket. " << llendl;
+
+                                if(mOwner)
+                                {
+                                        mOwner->socketError(status);
+                                }
+                                result = false;
+                        }
+                        else 
+                        {
+                                // some other error
+                                // Treat this as fatal.
+                                ll_apr_warn_status(status);
+                                
+                                if(mOwner)
+                                {
+                                        mOwner->socketError(status);
+                                }
+                                result = false;
+                        }
+                }
+        }
+        
+        return result;
+}
+
+bool LLPluginMessagePipe::pumpInput(F64 timeout)
+{
+        bool result = true;
+
+        if(mSocket)
+        {
+                apr_status_t status;
+                apr_size_t size;
+
+                // FIXME: For some reason, the apr timeout stuff isn't working properly on windows.
+                // Until such time as we figure out why, don't try to use the socket timeout -- just sleep here instead.
+#if LL_WINDOWS
+                if(result)
+                {
+                        if(timeout != 0.0f)
+                        {
+                                ms_sleep((int)(timeout * 1000.0f));
+                                timeout = 0.0f;
+                        }
+                }
+#endif
+                
+                // Check for incoming messages
+                if(result)
+                {
+                        char input_buf[1024];
+                        apr_size_t request_size;
+                        
+                        if(timeout == 0.0f)
+                        {
+                                // If we have no timeout, start out with a full read.
+                                request_size = sizeof(input_buf);
+                        }
+                        else
+                        {
+                                // Start out by reading one byte, so that any data received will wake us up.
+                                request_size = 1;
+                        }
+                        
+                        // and use the timeout so we'll sleep if no data is available.
+                        setSocketTimeout((apr_interval_time_t)(timeout * 1000000));
+
+                        while(1)                
+                        {
+                                size = request_size;
+
+//                              LL_INFOS("PluginPipe") << "before apr_socket_recv, size = " << size << LL_ENDL;
+
+                                status = apr_socket_recv(
+                                                mSocket->getSocket(),
+                                                input_buf,
+                                                &size);
+
+//                              LL_INFOS("PluginPipe") << "after apr_socket_recv, size = " << size << LL_ENDL;
+
+                                if(size > 0)
+                                {
+                                        LLMutexLock lock(&mInputMutex);
+                                        mInput.append(input_buf, size);
+                                }
+
+                                if(status == APR_SUCCESS)
+                                {
+                                        LL_DEBUGS("PluginSocket") << "success, read " << size << LL_ENDL;
+
+                                        if(size != request_size)
+                                        {
+                                                // This was a short read, so we're done.
+                                                break;
+                                        }
+                                }
+                                else if(APR_STATUS_IS_TIMEUP(status))
+                                {
+                                        LL_DEBUGS("PluginSocket") << "TIMEUP, read " << size << LL_ENDL;
+
+                                        // Timeout was hit.  Since the initial read is 1 byte, this should never be a partial read.
+                                        break;
+                                }
+                                else if(APR_STATUS_IS_EAGAIN(status))
+                                {
+                                        LL_DEBUGS("PluginSocket") << "EAGAIN, read " << size << LL_ENDL;
+
+                                        // Non-blocking read returned immediately.
+                                        break;
+                                }
+                                else if(APR_STATUS_IS_EOF(status))
+                                {
+                                        // This is what we normally expect when a plugin exits.
+                                        LL_INFOS("PluginSocket") << "Got EOF from plugin socket. " << LL_ENDL;
+
+                                        if(mOwner)
+                                        {
+                                                mOwner->socketError(status);
+                                        }
+                                        result = false;
+                                        break;
+                                }
+                                else
+                                {
+                                        // some other error
+                                        // Treat this as fatal.
+                                        ll_apr_warn_status(status);
+
+                                        if(mOwner)
+                                        {
+                                                mOwner->socketError(status);
+                                        }
+                                        result = false;
+                                        break;
+                                }
+
+                                if(timeout != 0.0f)
+                                {
+                                        // Second and subsequent reads should not use the timeout
+                                        setSocketTimeout(0);
+                                        // and should try to fill the input buffer
+                                        request_size = sizeof(input_buf);
+                                }
+                        }
+                        
+                        processInput();
+                }
+        }
+        
+        return result;  
+}
+
+void LLPluginMessagePipe::processInput(void)
+{
+        // Look for input delimiter(s) in the input buffer.
+        int delim;
+        mInputMutex.lock();
+        while((delim = mInput.find(MESSAGE_DELIMITER)) != std::string::npos)
+        {       
+                // Let the owner process this message
+                if (mOwner)
+                {
+                        // Pull the message out of the input buffer before calling receiveMessageRaw.
+                        // It's now possible for this function to get called recursively (in the case where the plugin makes a blocking request)
+                        // and this guarantees that the messages will get dequeued correctly.
+                        std::string message(mInput, 0, delim);
+                        mInput.erase(0, delim + 1);
+                        mInputMutex.unlock();
+                        mOwner->receiveMessageRaw(message);
+                        mInputMutex.lock();
+                }
+                else
+                {
+                        LL_WARNS("PluginPipe") << "!mOwner" << LL_ENDL;
+                }
+        }
+        mInputMutex.unlock();
+}
+
diff --git a/linden/indra/llplugin/llpluginmessagepipe.h b/linden/indra/llplugin/llpluginmessagepipe.h
new file mode 100755
index 0000000..6eedca2
--- /dev/null
+++ b/linden/indra/llplugin/llpluginmessagepipe.h
@@ -0,0 +1,100 @@
+/** 
+ * @file llpluginmessagepipe.h
+ * @brief Classes that implement connections from the plugin system to pipes/pumps.
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+#ifndef LL_LLPLUGINMESSAGEPIPE_H
+#define LL_LLPLUGINMESSAGEPIPE_H
+
+#include "lliosocket.h"
+#include "llthread.h"
+
+class LLPluginMessagePipe;
+
+// Inherit from this to be able to receive messages from the LLPluginMessagePipe
+class LLPluginMessagePipeOwner
+{
+        LOG_CLASS(LLPluginMessagePipeOwner);
+public:
+        LLPluginMessagePipeOwner();
+        virtual ~LLPluginMessagePipeOwner();
+        // called with incoming messages
+        virtual void receiveMessageRaw(const std::string &message) = 0;
+        // called when the socket has an error
+        virtual apr_status_t socketError(apr_status_t error);
+
+        // called from LLPluginMessagePipe to manage the connection with LLPluginMessagePipeOwner -- do not use!
+        virtual void setMessagePipe(LLPluginMessagePipe *message_pipe);
+
+protected:
+        // returns false if writeMessageRaw() would drop the message
+        bool canSendMessage(void);
+        // call this to send a message over the pipe
+        bool writeMessageRaw(const std::string &message);
+        // call this to close the pipe
+        void killMessagePipe(void);
+        
+        LLPluginMessagePipe *mMessagePipe;
+        apr_status_t mSocketError;
+};
+
+class LLPluginMessagePipe
+{
+        LOG_CLASS(LLPluginMessagePipe);
+public:
+        LLPluginMessagePipe(LLPluginMessagePipeOwner *owner, LLSocket::ptr_t socket);
+        virtual ~LLPluginMessagePipe();
+        
+        bool addMessage(const std::string &message);
+        void clearOwner(void);
+        
+        bool pump(F64 timeout = 0.0f);
+        bool pumpOutput();
+        bool pumpInput(F64 timeout = 0.0f);
+                
+protected:      
+        void processInput(void);
+
+        // used internally by pump()
+        void setSocketTimeout(apr_interval_time_t timeout_usec);
+        
+        LLMutex mInputMutex;
+        std::string mInput;
+        LLMutex mOutputMutex;
+        std::string mOutput;
+
+        LLPluginMessagePipeOwner *mOwner;
+        LLSocket::ptr_t mSocket;
+};
+
+#endif // LL_LLPLUGINMESSAGE_H
diff --git a/linden/indra/llplugin/llpluginprocesschild.cpp b/linden/indra/llplugin/llpluginprocesschild.cpp
new file mode 100755
index 0000000..0d95cac
--- /dev/null
+++ b/linden/indra/llplugin/llpluginprocesschild.cpp
@@ -0,0 +1,571 @@
+/** 
+ * @file llpluginprocesschild.cpp
+ * @brief LLPluginProcessChild handles the child side of the external-process plugin API. 
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+/// IMPRUDENCE: this is part of the SLPlugin
+
+#include "linden_common.h"
+
+#include "llpluginprocesschild.h"
+#include "llplugininstance.h"
+#include "llpluginmessagepipe.h"
+#include "llpluginmessageclasses.h"
+
+static const F32 HEARTBEAT_SECONDS = 1.0f;
+static const F32 PLUGIN_IDLE_SECONDS = 1.0f / 100.0f;  // Each call to idle will give the plugin this much time.
+
+LLPluginProcessChild::LLPluginProcessChild()
+{
+        mState = STATE_UNINITIALIZED;
+        mInstance = NULL;
+        mSocket = LLSocket::create(LLSocket::STREAM_TCP);
+        mSleepTime = PLUGIN_IDLE_SECONDS;       // default: send idle messages at 100Hz
+        mCPUElapsed = 0.0f;
+        mBlockingRequest = false;
+        mBlockingResponseReceived = false;
+}
+
+LLPluginProcessChild::~LLPluginProcessChild()
+{
+        if(mInstance != NULL)
+        {
+                sendMessageToPlugin(LLPluginMessage("base", "cleanup"));
+
+                // IMPORTANT: under some (unknown) circumstances the apr_dso_unload() triggered when mInstance is deleted 
+                // appears to fail and lock up which means that a given instance of the slplugin process never exits. 
+                // This is bad, especially when users try to update their version of SL - it fails because the slplugin 
+                // process as well as a bunch of plugin specific files are locked and cannot be overwritten.
+                exit( 0 );
+                //delete mInstance;
+                //mInstance = NULL;
+        }
+}
+
+void LLPluginProcessChild::killSockets(void)
+{
+        killMessagePipe();
+        mSocket.reset();
+}
+
+void LLPluginProcessChild::init(U32 launcher_port)
+{
+        mLauncherHost = LLHost("127.0.0.1", launcher_port);
+        setState(STATE_INITIALIZED);
+}
+
+void LLPluginProcessChild::idle(void)
+{
+        bool idle_again;
+        do
+        {
+                if(APR_STATUS_IS_EOF(mSocketError))
+                {
+                        // Plugin socket was closed.  This covers both normal plugin termination and host crashes.
+                        setState(STATE_ERROR);
+                }
+                else if(mSocketError != APR_SUCCESS)
+                {
+                        LL_INFOS("PluginChild") << "message pipe is in error state (" << mSocketError << "), moving to STATE_ERROR"<< LL_ENDL;
+                        setState(STATE_ERROR);
+                }
+
+                if((mState > STATE_INITIALIZED) && (mMessagePipe == NULL))
+                {
+                        // The pipe has been closed -- we're done.
+                        // TODO: This could be slightly more subtle, but I'm not sure it needs to be.
+                        LL_INFOS("PluginChild") << "message pipe went away, moving to STATE_ERROR"<< LL_ENDL;
+                        setState(STATE_ERROR);
+                }
+
+                // If a state needs to go directly to another state (as a performance enhancement), it can set idle_again to true after calling setState().
+                // USE THIS CAREFULLY, since it can starve other code.  Specifically make sure there's no way to get into a closed cycle and never return.
+                // When in doubt, don't do it.
+                idle_again = false;
+                
+                if(mInstance != NULL)
+                {
+                        // Provide some time to the plugin
+                        mInstance->idle();
+                }
+                
+                switch(mState)
+                {
+                        case STATE_UNINITIALIZED:
+                        break;
+
+                        case STATE_INITIALIZED:
+                                if(mSocket->blockingConnect(mLauncherHost))
+                                {
+                                        // This automatically sets mMessagePipe
+                                        new LLPluginMessagePipe(this, mSocket);
+                                        
+                                        setState(STATE_CONNECTED);
+                                }
+                                else
+                                {
+                                        // connect failed
+                                        setState(STATE_ERROR);
+                                }
+                        break;
+                        
+                        case STATE_CONNECTED:
+                                sendMessageToParent(LLPluginMessage(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "hello"));
+                                setState(STATE_PLUGIN_LOADING);
+                        break;
+                                                
+                        case STATE_PLUGIN_LOADING:
+                                if(!mPluginFile.empty())
+                                {
+                                        mInstance = new LLPluginInstance(this);
+                                        if(mInstance->load(mPluginFile) == 0)
+                                        {
+                                                mHeartbeat.start();
+                                                mHeartbeat.setTimerExpirySec(HEARTBEAT_SECONDS);
+                                                mCPUElapsed = 0.0f;
+                                                setState(STATE_PLUGIN_LOADED);
+                                        }
+                                        else
+                                        {
+                                                setState(STATE_ERROR);
+                                        }
+                                }
+                        break;
+                        
+                        case STATE_PLUGIN_LOADED:
+                                {
+                                        setState(STATE_PLUGIN_INITIALIZING);
+                                        LLPluginMessage message("base", "init");
+                                        sendMessageToPlugin(message);
+                                }
+                        break;
+                        
+                        case STATE_PLUGIN_INITIALIZING:
+                                // waiting for init_response...
+                        break;
+                        
+                        case STATE_RUNNING:
+                                if(mInstance != NULL)
+                                {
+                                        // Provide some time to the plugin
+                                        LLPluginMessage message("base", "idle");
+                                        message.setValueReal("time", PLUGIN_IDLE_SECONDS);
+                                        sendMessageToPlugin(message);
+                                        
+                                        mInstance->idle();
+                                        
+                                        if(mHeartbeat.hasExpired())
+                                        {
+                                                
+                                                // This just proves that we're not stuck down inside the plugin code.
+                                                LLPluginMessage heartbeat(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "heartbeat");
+                                                
+                                                // Calculate the approximage CPU usage fraction (floating point value between 0 and 1) used by the plugin this heartbeat cycle.
+                                                // Note that this will not take into account any threads or additional processes the plugin spawns, but it's a first approximation.
+                                                // If we could write OS-specific functions to query the actual CPU usage of this process, that would be a better approximation.
+                                                heartbeat.setValueReal("cpu_usage", mCPUElapsed / mHeartbeat.getElapsedTimeF64());
+                                                
+                                                sendMessageToParent(heartbeat);
+
+                                                mHeartbeat.reset();
+                                                mHeartbeat.setTimerExpirySec(HEARTBEAT_SECONDS);
+                                                mCPUElapsed = 0.0f;
+                                        }
+                                }
+                                // receivePluginMessage will transition to STATE_UNLOADING
+                        break;
+
+                        case STATE_UNLOADING:
+                                if(mInstance != NULL)
+                                {
+                                        sendMessageToPlugin(LLPluginMessage("base", "cleanup"));
+                                        delete mInstance;
+                                        mInstance = NULL;
+                                }
+                                setState(STATE_UNLOADED);
+                        break;
+                        
+                        case STATE_UNLOADED:
+                                killSockets();
+                                setState(STATE_DONE);
+                        break;
+
+                        case STATE_ERROR:
+                                // Close the socket to the launcher
+                                killSockets();                          
+                                // TODO: Where do we go from here?  Just exit()?
+                                setState(STATE_DONE);
+                        break;
+                        
+                        case STATE_DONE:
+                                // just sit here.
+                        break;
+                }
+        
+        } while (idle_again);
+}
+
+void LLPluginProcessChild::sleep(F64 seconds)
+{
+        deliverQueuedMessages();
+        if(mMessagePipe)
+        {
+                mMessagePipe->pump(seconds);
+        }
+        else
+        {
+                ms_sleep((int)(seconds * 1000.0f));
+        }
+}
+
+void LLPluginProcessChild::pump(void)
+{
+        deliverQueuedMessages();
+        if(mMessagePipe)
+        {
+                mMessagePipe->pump(0.0f);
+        }
+        else
+        {
+                // Should we warn here?
+        }
+}
+
+
+bool LLPluginProcessChild::isRunning(void)
+{
+        bool result = false;
+        
+        if(mState == STATE_RUNNING)
+                result = true;
+                
+        return result;
+}
+
+bool LLPluginProcessChild::isDone(void)
+{
+        bool result = false;
+        
+        switch(mState)
+        {
+                case STATE_DONE:
+                result = true;
+                break;
+                default:
+                break;
+        }
+                
+        return result;
+}
+
+void LLPluginProcessChild::sendMessageToPlugin(const LLPluginMessage &message)
+{
+        if (mInstance)
+        {
+                std::string buffer = message.generate();
+
+                LL_DEBUGS("PluginChild") << "Sending to plugin: " << buffer << LL_ENDL;
+                LLTimer elapsed;
+
+                mInstance->sendMessage(buffer);
+                
+                mCPUElapsed += elapsed.getElapsedTimeF64();
+        }
+        else
+        {
+                LL_WARNS("PluginChild") << "mInstance == NULL" << LL_ENDL;
+        }
+}
+
+void LLPluginProcessChild::sendMessageToParent(const LLPluginMessage &message)
+{
+        std::string buffer = message.generate();
+
+        LL_DEBUGS("PluginChild") << "Sending to parent: " << buffer << LL_ENDL;
+
+        writeMessageRaw(buffer);
+}
+
+void LLPluginProcessChild::receiveMessageRaw(const std::string &message)
+{
+        // Incoming message from the TCP Socket
+
+        LL_DEBUGS("PluginChild") << "Received from parent: " << message << LL_ENDL;
+
+        // Decode this message
+        LLPluginMessage parsed;
+        parsed.parse(message);
+
+        if(mBlockingRequest)
+        {
+                // We're blocking the plugin waiting for a response.
+
+                if(parsed.hasValue("blocking_response"))
+                {
+                        // This is the message we've been waiting for -- fall through and send it immediately. 
+                        mBlockingResponseReceived = true;
+                }
+                else
+                {
+                        // Still waiting.  Queue this message and don't process it yet.
+                        mMessageQueue.push(message);
+                        return;
+                }
+        }
+        
+        bool passMessage = true;
+        
+        // FIXME: how should we handle queueing here?
+        
+        {
+                std::string message_class = parsed.getClass();
+                if(message_class == LLPLUGIN_MESSAGE_CLASS_INTERNAL)
+                {
+                        passMessage = false;
+                        
+                        std::string message_name = parsed.getName();
+                        if(message_name == "load_plugin")
+                        {
+                                mPluginFile = parsed.getValue("file");
+                        }
+                        else if(message_name == "shm_add")
+                        {
+                                std::string name = parsed.getValue("name");
+                                size_t size = (size_t)parsed.getValueS32("size");
+                                
+                                sharedMemoryRegionsType::iterator iter = mSharedMemoryRegions.find(name);
+                                if(iter != mSharedMemoryRegions.end())
+                                {
+                                        // Need to remove the old region first
+                                        LL_WARNS("PluginChild") << "Adding a duplicate shared memory segment!" << LL_ENDL;
+                                }
+                                else
+                                {
+                                        // This is a new region
+                                        LLPluginSharedMemory *region = new LLPluginSharedMemory;
+                                        if(region->attach(name, size))
+                                        {
+                                                mSharedMemoryRegions.insert(sharedMemoryRegionsType::value_type(name, region));
+                                                
+                                                std::stringstream addr;
+                                                addr << region->getMappedAddress();
+                                                
+                                                // Send the add notification to the plugin
+                                                LLPluginMessage message("base", "shm_added");
+                                                message.setValue("name", name);
+                                                message.setValueS32("size", (S32)size);
+                                                message.setValuePointer("address", region->getMappedAddress());
+                                                sendMessageToPlugin(message);
+                                                
+                                                // and send the response to the parent
+                                                message.setMessage(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "shm_add_response");
+                                                message.setValue("name", name);
+                                                sendMessageToParent(message);
+                                        }
+                                        else
+                                        {
+                                                LL_WARNS("PluginChild") << "Couldn't create a shared memory segment!" << LL_ENDL;
+                                                delete region;
+                                        }
+                                }
+                                
+                        }
+                        else if(message_name == "shm_remove")
+                        {
+                                std::string name = parsed.getValue("name");
+                                sharedMemoryRegionsType::iterator iter = mSharedMemoryRegions.find(name);
+                                if(iter != mSharedMemoryRegions.end())
+                                {
+                                        // forward the remove request to the plugin -- its response will trigger us to detach the segment.
+                                        LLPluginMessage message("base", "shm_remove");
+                                        message.setValue("name", name);
+                                        sendMessageToPlugin(message);
+                                }
+                                else
+                                {
+                                        LL_WARNS("PluginChild") << "shm_remove for unknown memory segment!" << LL_ENDL;
+                                }
+                        }
+                        else if(message_name == "sleep_time")
+                        {
+                                mSleepTime = parsed.getValueReal("time");
+                        }
+                        else if(message_name == "crash")
+                        {
+                                // Crash the plugin
+                                LL_ERRS("PluginChild") << "Plugin crash requested." << LL_ENDL;
+                        }
+                        else if(message_name == "hang")
+                        {
+                                // Hang the plugin
+                                LL_WARNS("PluginChild") << "Plugin hang requested." << LL_ENDL;
+                                while(1)
+                                {
+                                        // wheeeeeeeee......
+                                }
+                        }
+                        else
+                        {
+                                LL_WARNS("PluginChild") << "Unknown internal message from parent: " << message_name << LL_ENDL;
+                        }
+                }
+        }
+        
+        if(passMessage && mInstance != NULL)
+        {
+                LLTimer elapsed;
+
+                mInstance->sendMessage(message);
+
+                mCPUElapsed += elapsed.getElapsedTimeF64();
+        }
+}
+
+/* virtual */
+void LLPluginProcessChild::receivePluginMessage(const std::string &message)
+{
+        LL_DEBUGS("PluginChild") << "Received from plugin: " << message << LL_ENDL;
+
+        if(mBlockingRequest)
+        {
+                //
+                LL_ERRS("PluginChild") << "Can't send a message while already waiting on a blocking request -- aborting!" << LL_ENDL;
+        }
+
+        // Incoming message from the plugin instance
+        bool passMessage = true;
+
+        // FIXME: how should we handle queueing here?
+        
+        // Intercept certain base messages (responses to ones sent by this class)
+        {
+                // Decode this message
+                LLPluginMessage parsed;
+                parsed.parse(message);
+                
+                if(parsed.hasValue("blocking_request"))
+                {
+                        mBlockingRequest = true;
+                }
+
+                std::string message_class = parsed.getClass();
+                if(message_class == "base")
+                {
+                        std::string message_name = parsed.getName();
+                        if(message_name == "init_response")
+                        {
+                                // The plugin has finished initializing.
+                                setState(STATE_RUNNING);
+
+                                // Don't pass this message up to the parent
+                                passMessage = false;
+                                
+                                LLPluginMessage new_message(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "load_plugin_response");
+                                LLSD versions = parsed.getValueLLSD("versions");
+                                new_message.setValueLLSD("versions", versions);
+                                
+                                if(parsed.hasValue("plugin_version"))
+                                {
+                                        std::string plugin_version = parsed.getValue("plugin_version");
+                                        new_message.setValueLLSD("plugin_version", plugin_version);
+                                }
+
+                                // Let the parent know it's loaded and initialized.
+                                sendMessageToParent(new_message);
+                        }
+                        else if(message_name == "shm_remove_response")
+                        {
+                                // Don't pass this message up to the parent
+                                passMessage = false;
+
+                                std::string name = parsed.getValue("name");
+                                sharedMemoryRegionsType::iterator iter = mSharedMemoryRegions.find(name);                               
+                                if(iter != mSharedMemoryRegions.end())
+                                {
+                                        // detach the shared memory region
+                                        iter->second->detach();
+                                        
+                                        // and remove it from our map
+                                        mSharedMemoryRegions.erase(iter);
+                                        
+                                        // Finally, send the response to the parent.
+                                        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "shm_remove_response");
+                                        message.setValue("name", name);
+                                        sendMessageToParent(message);
+                                }
+                                else
+                                {
+                                        LL_WARNS("PluginChild") << "shm_remove_response for unknown memory segment!" << LL_ENDL;
+                                }
+                        }
+                }
+        }
+
+        if(passMessage)
+        {
+                LL_DEBUGS("PluginChild") << "Passing through to parent: " << message << LL_ENDL;
+                writeMessageRaw(message);
+        }
+
+        while(mBlockingRequest)
+        {
+                // The plugin wants to block and wait for a response to this message.
+                sleep(mSleepTime);      // this will pump the message pipe and process messages
+
+                if(mBlockingResponseReceived || mSocketError != APR_SUCCESS || (mMessagePipe == NULL))
+                {
+                        // Response has been received, or we've hit an error state.  Stop waiting.
+                        mBlockingRequest = false;
+                        mBlockingResponseReceived = false;
+                }
+        }
+}
+
+
+void LLPluginProcessChild::setState(EState state)
+{
+        LL_DEBUGS("PluginChild") << "setting state to " << state << LL_ENDL;
+        mState = state;
+};
+
+void LLPluginProcessChild::deliverQueuedMessages()
+{
+        if(!mBlockingRequest)
+        {
+                while(!mMessageQueue.empty())
+                {
+                        receiveMessageRaw(mMessageQueue.front());
+                        mMessageQueue.pop();
+                }
+        }
+}
diff --git a/linden/indra/llplugin/llpluginprocesschild.h b/linden/indra/llplugin/llpluginprocesschild.h
new file mode 100755
index 0000000..5d643d7
--- /dev/null
+++ b/linden/indra/llplugin/llpluginprocesschild.h
@@ -0,0 +1,121 @@
+/** 
+ * @file llpluginprocesschild.h
+ * @brief LLPluginProcessChild handles the child side of the external-process plugin API. 
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+#ifndef LL_LLPLUGINPROCESSCHILD_H
+#define LL_LLPLUGINPROCESSCHILD_H
+
+#include <queue> //imprudence
+
+#include "llpluginmessage.h"
+#include "llpluginmessagepipe.h"
+#include "llplugininstance.h"
+#include "llhost.h"
+#include "llpluginsharedmemory.h"
+
+class LLPluginInstance;
+
+class LLPluginProcessChild: public LLPluginMessagePipeOwner, public LLPluginInstanceMessageListener
+{
+        LOG_CLASS(LLPluginProcessChild);
+public:
+        LLPluginProcessChild();
+        ~LLPluginProcessChild();
+
+        void init(U32 launcher_port);
+        void idle(void);
+        void sleep(F64 seconds);
+        void pump();
+
+        // returns true if the plugin is in the steady state (processing messages)
+        bool isRunning(void);
+        
+        // returns true if the plugin is unloaded or we're in an unrecoverable error state.     
+        bool isDone(void);
+        
+        void killSockets(void);
+
+        F64 getSleepTime(void) const { return mSleepTime; };
+        
+        void sendMessageToPlugin(const LLPluginMessage &message);
+        void sendMessageToParent(const LLPluginMessage &message);
+        
+        // Inherited from LLPluginMessagePipeOwner
+        /* virtual */ void receiveMessageRaw(const std::string &message);
+
+        // Inherited from LLPluginInstanceMessageListener
+        /* virtual */ void receivePluginMessage(const std::string &message);
+        
+private:
+
+        enum EState
+        {
+                STATE_UNINITIALIZED,
+                STATE_INITIALIZED,                      // init() has been called
+                STATE_CONNECTED,                        // connected back to launcher
+                STATE_PLUGIN_LOADING,           // plugin library needs to be loaded
+                STATE_PLUGIN_LOADED,            // plugin library has been loaded
+                STATE_PLUGIN_INITIALIZING,      // plugin is processing init message
+                STATE_RUNNING,                          // steady state (processing messages)
+                STATE_UNLOADING,                        // plugin has sent shutdown_response and needs to be unloaded
+                STATE_UNLOADED,                         // plugin has been unloaded
+                STATE_ERROR,                            // generic bailout state
+                STATE_DONE                                      // state machine will sit in this state after either error or normal termination.
+        };
+        void setState(EState state);
+
+        EState mState;
+        
+        LLHost mLauncherHost;
+        LLSocket::ptr_t mSocket;
+        
+        std::string mPluginFile;
+
+        LLPluginInstance *mInstance;
+
+        typedef std::map<std::string, LLPluginSharedMemory*> sharedMemoryRegionsType;
+        sharedMemoryRegionsType mSharedMemoryRegions;
+        
+        LLTimer mHeartbeat;
+        F64             mSleepTime;
+        F64             mCPUElapsed;
+        bool    mBlockingRequest;
+        bool    mBlockingResponseReceived;
+        std::queue<std::string> mMessageQueue;
+        
+        void deliverQueuedMessages();
+        
+};
+
+#endif // LL_LLPLUGINPROCESSCHILD_H
diff --git a/linden/indra/llplugin/llpluginprocessparent.cpp b/linden/indra/llplugin/llpluginprocessparent.cpp
new file mode 100755
index 0000000..26572a0
--- /dev/null
+++ b/linden/indra/llplugin/llpluginprocessparent.cpp
@@ -0,0 +1,1161 @@
+/** 
+ * @file llpluginprocessparent.cpp
+ * @brief LLPluginProcessParent handles the parent side of the external-process plugin API.
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+/// IMPRUDENCE: this is part of the viewer
+
+#include "linden_common.h"
+
+#include "llpluginprocessparent.h"
+#include "llpluginmessagepipe.h"
+#include "llpluginmessageclasses.h"
+
+#include "llapr.h"
+
+//virtual 
+LLPluginProcessParentOwner::~LLPluginProcessParentOwner()
+{
+        
+}
+
+bool LLPluginProcessParent::sUseReadThread = false;
+apr_pollset_t *LLPluginProcessParent::sPollSet = NULL;
+AIAPRPool LLPluginProcessParent::sPollSetPool;
+bool LLPluginProcessParent::sPollsetNeedsRebuild = false;
+LLMutex *LLPluginProcessParent::sInstancesMutex;
+std::list<LLPluginProcessParent*> LLPluginProcessParent::sInstances;
+LLThread *LLPluginProcessParent::sReadThread = NULL;
+
+
+class LLPluginProcessParentPollThread: public LLThread
+{
+public:
+        LLPluginProcessParentPollThread() :
+                LLThread("LLPluginProcessParentPollThread")
+        {
+        }
+protected:
+        // Inherited from LLThread
+        /*virtual*/ void run(void)
+        {
+                while(!isQuitting() && LLPluginProcessParent::getUseReadThread())
+                {
+                        LLPluginProcessParent::poll(0.1f);
+                        checkPause();
+                }
+                
+                // Final poll to clean up the pollset, etc.
+                LLPluginProcessParent::poll(0.0f);
+        } 
+
+        // Inherited from LLThread
+        /*virtual*/ bool runCondition(void)
+        {
+                return(LLPluginProcessParent::canPollThreadRun());
+        }
+
+};
+
+LLPluginProcessParent::LLPluginProcessParent(LLPluginProcessParentOwner *owner)
+{
+        if(!sInstancesMutex)
+        {
+                sInstancesMutex = new LLMutex;
+        }
+        
+        mOwner = owner;
+        mBoundPort = 0;
+        mState = STATE_UNINITIALIZED;
+        mSleepTime = 0.0;
+        mCPUUsage = 0.0;
+        mDisableTimeout = false;
+        mDebug = false;
+        mBlocked = false;
+        mPolledInput = false;
+        mPollFD.client_data = NULL;
+        mPollFDPool.create();
+
+        mPluginLaunchTimeout = 60.0f;
+        mPluginLockupTimeout = 15.0f;
+        
+        // Don't start the timer here -- start it when we actually launch the plugin process.
+        mHeartbeat.stop();
+
+        
+        // Don't add to the global list until fully constructed.
+        {
+                LLMutexLock lock(sInstancesMutex);
+                sInstances.push_back(this);
+        }
+}
+
+LLPluginProcessParent::~LLPluginProcessParent()
+{
+        LL_DEBUGS("PluginParent") << "destructor" << LL_ENDL;
+
+        // Remove from the global list before beginning destruction.
+        {
+                // Make sure to get the global mutex _first_ here, to avoid a possible deadlock against LLPluginProcessParent::poll()
+                LLMutexLock lock(sInstancesMutex);
+                {
+                        LLMutexLock lock2(&mIncomingQueueMutex);
+                        sInstances.remove(this);
+                }
+        }
+
+        // Destroy any remaining shared memory regions
+        sharedMemoryRegionsType::iterator iter;
+        while((iter = mSharedMemoryRegions.begin()) != mSharedMemoryRegions.end())
+        {
+                // destroy the shared memory region
+                iter->second->destroy();
+                
+                // and remove it from our map
+                mSharedMemoryRegions.erase(iter);
+        }
+        
+        mProcess.kill();
+        killSockets();
+}
+
+void LLPluginProcessParent::killSockets(void)
+{
+        {
+                LLMutexLock lock(&mIncomingQueueMutex);
+                killMessagePipe();
+        }
+
+        mListenSocket.reset();
+        mSocket.reset();
+}
+
+void LLPluginProcessParent::errorState(void)
+{
+        if(mState < STATE_RUNNING)
+                setState(STATE_LAUNCH_FAILURE);
+        else
+                setState(STATE_ERROR);
+}
+
+void LLPluginProcessParent::init(const std::string &launcher_filename, const std::string &plugin_filename, bool debug)
+{       
+        mProcess.setExecutable(launcher_filename);
+        mPluginFile = plugin_filename;
+        mCPUUsage = 0.0f;
+        mDebug = debug; 
+        setState(STATE_INITIALIZED);
+}
+
+bool LLPluginProcessParent::accept()
+{
+        bool result = false;
+        apr_status_t status = APR_EGENERAL;
+
+        mSocket = LLSocket::create(status, mListenSocket);
+        
+        if(status == APR_SUCCESS)
+        {
+//              llinfos << "SUCCESS" << llendl;
+                // Success.  Create a message pipe on the new socket
+                new LLPluginMessagePipe(this, mSocket);
+
+                result = true;
+        }
+        else
+        {
+                mSocket.reset();
+                // EAGAIN means "No incoming connections". This is not an error.
+                if (!APR_STATUS_IS_EAGAIN(status))
+                {
+                        // Some other error.
+                        ll_apr_warn_status(status);
+                        errorState();
+                }
+        }
+        
+        return result;  
+}
+
+void LLPluginProcessParent::idle(void)
+{
+        bool idle_again;
+
+        do
+        {
+                // process queued messages
+                mIncomingQueueMutex.lock();
+                while(!mIncomingQueue.empty())
+                {
+                        LLPluginMessage message = mIncomingQueue.front();
+                        mIncomingQueue.pop();
+                        mIncomingQueueMutex.unlock();
+                                
+                        receiveMessage(message);
+                        
+                        mIncomingQueueMutex.lock();
+                }
+
+                mIncomingQueueMutex.unlock();
+                
+                // Give time to network processing
+                if(mMessagePipe)
+                {
+                        // Drain any queued outgoing messages
+                        mMessagePipe->pumpOutput();
+                        
+                        // Only do input processing here if this instance isn't in a pollset.
+                        if(!mPolledInput)
+                        {
+                                mMessagePipe->pumpInput();
+                        }
+                }
+                
+                if(mState <= STATE_RUNNING)
+                {
+                        if(APR_STATUS_IS_EOF(mSocketError))
+                        {
+                                // Plugin socket was closed.  This covers both normal plugin termination and plugin crashes.
+                                errorState();
+                        }
+                        else if(mSocketError != APR_SUCCESS)
+                        {
+                                // The socket is in an error state -- the plugin is gone.
+                                LL_WARNS("PluginParent") << "Socket hit an error state (" << mSocketError << ")" << LL_ENDL;
+                                errorState();
+                        }
+                }
+                
+                // If a state needs to go directly to another state (as a performance enhancement), it can set idle_again to true after calling setState().
+                // USE THIS CAREFULLY, since it can starve other code.  Specifically make sure there's no way to get into a closed cycle and never return.
+                // When in doubt, don't do it.
+                idle_again = false;
+                switch(mState)
+                {
+                        case STATE_UNINITIALIZED:
+                        break;
+
+                        case STATE_INITIALIZED:
+                        {
+        
+                                apr_status_t status = APR_SUCCESS;
+                                apr_sockaddr_t* addr = NULL;
+                                mListenSocket = LLSocket::create(LLSocket::STREAM_TCP);
+                                mBoundPort = 0;
+                                
+                                // This code is based on parts of LLSocket::create() in lliosocket.cpp.
+                                
+                                status = apr_sockaddr_info_get(
+                                        &addr,
+                                        "127.0.0.1",
+                                        APR_INET,
+                                        0,      // port 0 = ephemeral ("find me a port")
+                                        0,
+                                        AIAPRRootPool::get()());
+                                        
+                                if(ll_apr_warn_status(status))
+                                {
+                                        killSockets();
+                                        errorState();
+                                        break;
+                                }
+
+                                // This allows us to reuse the address on quick down/up. This is unlikely to create problems.
+                                ll_apr_warn_status(apr_socket_opt_set(mListenSocket->getSocket(), APR_SO_REUSEADDR, 1));
+                                
+                                status = apr_socket_bind(mListenSocket->getSocket(), addr);
+                                if(ll_apr_warn_status(status))
+                                {
+                                        killSockets();
+                                        errorState();
+                                        break;
+                                }
+
+                                // Get the actual port the socket was bound to
+                                {
+                                        apr_sockaddr_t* bound_addr = NULL;
+                                        if(ll_apr_warn_status(apr_socket_addr_get(&bound_addr, APR_LOCAL, mListenSocket->getSocket())))
+                                        {
+                                                killSockets();
+                                                errorState();
+                                                break;
+                                        }
+                                        mBoundPort = bound_addr->port;  
+
+                                        if(mBoundPort == 0)
+                                        {
+                                                LL_WARNS("PluginParent") << "Bound port number unknown, bailing out." << LL_ENDL;
+
+                                                killSockets();
+                                                errorState();
+                                                break;
+                                        }
+                                }
+
+                                LL_DEBUGS("PluginParent") << "Bound tcp socket to port: " << addr->port << LL_ENDL;
+
+                                // Make the listen socket non-blocking
+                                status = apr_socket_opt_set(mListenSocket->getSocket(), APR_SO_NONBLOCK, 1);
+                                if(ll_apr_warn_status(status))
+                                {
+                                        killSockets();
+                                        errorState();
+                                        break;
+                                }
+
+                                apr_socket_timeout_set(mListenSocket->getSocket(), 0);
+                                if(ll_apr_warn_status(status))
+                                {
+                                        killSockets();
+                                        errorState();
+                                        break;
+                                }
+                                
+                                // If it's a stream based socket, we need to tell the OS
+                                // to keep a queue of incoming connections for ACCEPT.
+                                status = apr_socket_listen(
+                                        mListenSocket->getSocket(),
+                                        10); // FIXME: Magic number for queue size
+                                        
+                                if(ll_apr_warn_status(status))
+                                {
+                                        killSockets();
+                                        errorState();
+                                        break;
+                                }
+                                
+                                // If we got here, we're listening.
+                                setState(STATE_LISTENING);
+                        }
+                        break;
+                        
+                        case STATE_LISTENING:
+                        {
+                                // Launch the plugin process.
+                                
+                                // Only argument to the launcher is the port number we're listening on
+                                std::stringstream stream;
+                                stream << mBoundPort;
+                                mProcess.addArgument(stream.str());
+                                if(mProcess.launch() != 0)
+                                {
+                                        errorState();
+                                }
+                                else
+                                {
+                                        if(mDebug)
+                                        {
+                                                #if LL_DARWIN
+                                                // If we're set to debug, start up a gdb instance in a new terminal window and have it attach to the plugin process and continue.
+                                                
+                                                // The command we're constructing would look like this on the command line:
+                                                // osascript -e 'tell application "Terminal"' -e 'set win to do script "gdb -pid 12345"' -e 'do script "continue" in win' -e 'end tell'
+
+                                                std::stringstream cmd;
+                                                
+                                                mDebugger.setExecutable("/usr/bin/osascript");
+                                                mDebugger.addArgument("-e");
+                                                mDebugger.addArgument("tell application \"Terminal\"");
+                                                mDebugger.addArgument("-e");
+                                                cmd << "set win to do script \"gdb -pid " << mProcess.getProcessID() << "\"";
+                                                mDebugger.addArgument(cmd.str());
+                                                mDebugger.addArgument("-e");
+                                                mDebugger.addArgument("do script \"continue\" in win");
+                                                mDebugger.addArgument("-e");
+                                                mDebugger.addArgument("end tell");
+                                                mDebugger.launch();
+
+                                                #elif LL_LINUX
+
+                                                std::stringstream cmd;
+
+                                                mDebugger.setExecutable("/usr/bin/gnome-terminal");
+                                                mDebugger.addArgument("--geometry=165x24-0+0");
+                                                mDebugger.addArgument("-e");
+                                                cmd << "/usr/bin/gdb -n /proc/" << mProcess.getProcessID() << "/exe " << mProcess.getProcessID();
+                                                mDebugger.addArgument(cmd.str());
+                                                mDebugger.launch();
+
+                                                #endif
+                                        }
+                                        
+                                        // This will allow us to time out if the process never starts.
+                                        mHeartbeat.start();
+                                        mHeartbeat.setTimerExpirySec(mPluginLaunchTimeout);
+                                        setState(STATE_LAUNCHED);
+                                }
+                        }
+                        break;
+
+                        case STATE_LAUNCHED:
+                                // waiting for the plugin to connect
+                                if(pluginLockedUpOrQuit())
+                                {
+                                        errorState();
+                                }
+                                else
+                                {
+                                        // Check for the incoming connection.
+                                        if(accept())
+                                        {
+                                                // Stop listening on the server port
+                                                mListenSocket.reset();
+                                                setState(STATE_CONNECTED);
+                                        }
+                                }
+                        break;
+                        
+                        case STATE_CONNECTED:
+                                // waiting for hello message from the plugin
+
+                                if(pluginLockedUpOrQuit())
+                                {
+                                        errorState();
+                                }
+                        break;
+
+                        case STATE_HELLO:
+                                LL_DEBUGS("PluginParent") << "received hello message" << LL_ENDL;
+
+                                // Send the message to load the plugin
+                                {
+                                        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "load_plugin");
+                                        message.setValue("file", mPluginFile);
+                                        sendMessage(message);
+                                }
+
+                                setState(STATE_LOADING);
+                        break;
+                        
+                        case STATE_LOADING:
+                                // The load_plugin_response message will kick us from here into STATE_RUNNING
+                                if(pluginLockedUpOrQuit())
+                                {
+                                        errorState();
+                                }
+                        break;
+                        
+                        case STATE_RUNNING:
+                                if(pluginLockedUpOrQuit())
+                                {
+                                        errorState();
+                                }
+                        break;
+                        
+                        case STATE_EXITING:
+                                if(!mProcess.isRunning())
+                                {
+                                        setState(STATE_CLEANUP);
+                                }
+                                else if(pluginLockedUp())
+                                {
+                                        LL_WARNS("PluginParent") << "timeout in exiting state, bailing out" << LL_ENDL;
+                                        errorState();
+                                }
+                        break;
+
+                        case STATE_LAUNCH_FAILURE:
+                                if(mOwner != NULL)
+                                {
+                                        mOwner->pluginLaunchFailed();
+                                }
+                                setState(STATE_CLEANUP);
+                        break;
+
+                        case STATE_ERROR:
+                                if(mOwner != NULL)
+                                {
+                                        mOwner->pluginDied();
+                                }
+                                setState(STATE_CLEANUP);
+                        break;
+                        
+                        case STATE_CLEANUP:
+                                mProcess.kill();
+                                killSockets();
+                                setState(STATE_DONE);
+                        break;
+                        
+                        
+                        case STATE_DONE:
+                                // just sit here.
+                        break;
+                        
+                }
+        
+        } while (idle_again);
+}
+
+bool LLPluginProcessParent::isLoading(void)
+{
+        bool result = false;
+        
+        if(mState <= STATE_LOADING)
+                result = true;
+                
+        return result;
+}
+
+bool LLPluginProcessParent::isRunning(void)
+{
+        bool result = false;
+        
+        if(mState == STATE_RUNNING)
+                result = true;
+                
+        return result;
+}
+
+bool LLPluginProcessParent::isDone(void)
+{
+        bool result = false;
+        
+        if(mState == STATE_DONE)
+                result = true;
+                
+        return result;
+}
+
+void LLPluginProcessParent::setSleepTime(F64 sleep_time, bool force_send)
+{
+        if(force_send || (sleep_time != mSleepTime))
+        {
+                // Cache the time locally
+                mSleepTime = sleep_time;
+                
+                if(canSendMessage())
+                {
+                        // and send to the plugin.
+                        LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "sleep_time");
+                        message.setValueReal("time", mSleepTime);
+                        sendMessage(message);
+                }
+                else
+                {
+                        // Too early to send -- the load_plugin_response message will trigger us to send mSleepTime later.
+                }
+        }
+}
+
+void LLPluginProcessParent::sendMessage(const LLPluginMessage &message)
+{
+        if(message.hasValue("blocking_response"))
+        {
+                mBlocked = false;
+
+                // reset the heartbeat timer, since there will have been no heartbeats while the plugin was blocked.
+                mHeartbeat.setTimerExpirySec(mPluginLockupTimeout);
+        }
+
+        std::string buffer = message.generate();
+        LL_DEBUGS("PluginParent") << "Sending: " << buffer << LL_ENDL;
+        writeMessageRaw(buffer);
+
+        // Try to send message immediately.
+        if(mMessagePipe)
+        {
+                mMessagePipe->pumpOutput();
+        }
+}
+
+//virtual 
+void LLPluginProcessParent::setMessagePipe(LLPluginMessagePipe *message_pipe)
+{
+        bool update_pollset = false;
+        
+        if(mMessagePipe)
+        {
+                // Unsetting an existing message pipe -- remove from the pollset                
+                mPollFD.client_data = NULL;
+
+                // pollset needs an update
+                update_pollset = true;
+        }
+        if(message_pipe != NULL)
+        {
+                // Set up the apr_pollfd_t
+
+                mPollFD.p = mPollFDPool();
+                mPollFD.desc_type = APR_POLL_SOCKET;
+                mPollFD.reqevents = APR_POLLIN|APR_POLLERR|APR_POLLHUP;
+                mPollFD.rtnevents = 0;
+                mPollFD.desc.s = mSocket->getSocket();
+                mPollFD.client_data = (void*)this;      
+                
+                // pollset needs an update
+                update_pollset = true;
+        }
+
+        mMessagePipe = message_pipe;
+        
+        if(update_pollset)
+        {
+                dirtyPollSet();
+        }
+}
+
+//static 
+void LLPluginProcessParent::dirtyPollSet()
+{
+        sPollsetNeedsRebuild = true;
+        
+        if(sReadThread)
+        {
+                LL_DEBUGS("PluginPoll") << "unpausing read thread " << LL_ENDL;
+                sReadThread->unpause();
+        }
+}
+
+void LLPluginProcessParent::updatePollset()
+{
+        if(!sInstancesMutex)
+        {
+                // No instances have been created yet.  There's no work to do.
+                return;
+        }
+                
+        LLMutexLock lock(sInstancesMutex);
+
+        if(sPollSet)
+        {
+                LL_DEBUGS("PluginPoll") << "destroying pollset " << sPollSet << LL_ENDL;
+                // delete the existing pollset.
+                apr_pollset_destroy(sPollSet);
+                sPollSet = NULL;
+                sPollSetPool.destroy();
+        }
+        
+        std::list<LLPluginProcessParent*>::iterator iter;
+        int count = 0;
+        
+        // Count the number of instances that want to be in the pollset
+        for(iter = sInstances.begin(); iter != sInstances.end(); iter++)
+        {
+                (*iter)->mPolledInput = false;
+                if((*iter)->mPollFD.client_data)
+                {
+                        // This instance has a socket that needs to be polled.
+                        ++count;
+                }
+        }
+
+        if(sUseReadThread && sReadThread && !sReadThread->isQuitting())
+        {
+                if(!sPollSet && (count > 0))
+                {
+#ifdef APR_POLLSET_NOCOPY
+                        // The pollset doesn't exist yet.  Create it now.
+                        sPollSetPool.create();  
+                        apr_status_t status = apr_pollset_create(&sPollSet, count, sPollSetPool(), APR_POLLSET_NOCOPY);
+                        if(status != APR_SUCCESS)
+                        {
+#endif // APR_POLLSET_NOCOPY
+                                LL_WARNS("PluginPoll") << "Couldn't create pollset.  Falling back to non-pollset mode." << LL_ENDL;
+                                sPollSet = NULL;
+                                sPollSetPool.destroy();
+#ifdef APR_POLLSET_NOCOPY
+                        }
+                        else
+                        {
+                                LL_DEBUGS("PluginPoll") << "created pollset " << sPollSet << LL_ENDL;
+                                
+                                // Pollset was created, add all instances to it.
+                                for(iter = sInstances.begin(); iter != sInstances.end(); iter++)
+                                {
+                                        if((*iter)->mPollFD.client_data)
+                                        {
+                                                status = apr_pollset_add(sPollSet, &((*iter)->mPollFD));
+                                                if(status == APR_SUCCESS)
+                                                {
+                                                        (*iter)->mPolledInput = true;
+                                                }
+                                                else
+                                                {
+                                                        LL_WARNS("PluginPoll") << "apr_pollset_add failed with status " << status << LL_ENDL;
+                                                }
+                                        }
+                                }
+                        }
+#endif // APR_POLLSET_NOCOPY
+                }
+        }
+}
+
+void LLPluginProcessParent::setUseReadThread(bool use_read_thread)
+{
+        if(sUseReadThread != use_read_thread)
+        {
+                sUseReadThread = use_read_thread;
+                
+                if(sUseReadThread)
+                {
+                        if(!sReadThread)
+                        {
+                                // start up the read thread
+                                LL_INFOS("PluginPoll") << "creating read thread " << LL_ENDL;
+
+                                // make sure the pollset gets rebuilt.
+                                sPollsetNeedsRebuild = true;
+                                
+                                sReadThread = new LLPluginProcessParentPollThread;
+                                sReadThread->start();
+                        }
+                }
+                else
+                {
+                        if(sReadThread)
+                        {
+                                // shut down the read thread
+                                LL_INFOS("PluginPoll") << "destroying read thread " << LL_ENDL;
+                                delete sReadThread;
+                                sReadThread = NULL;
+                        }
+                }
+
+        }
+}
+
+void LLPluginProcessParent::poll(F64 timeout)
+{
+        if(sPollsetNeedsRebuild || !sUseReadThread)
+        {
+                sPollsetNeedsRebuild = false;
+                updatePollset();
+        }
+        
+        if(sPollSet)
+        {
+                apr_status_t status;
+                apr_int32_t count;
+                const apr_pollfd_t *descriptors;
+                status = apr_pollset_poll(sPollSet, (apr_interval_time_t)(timeout * 1000000), &count, &descriptors);
+                if(status == APR_SUCCESS)
+                {
+                        // One or more of the descriptors signalled.  Call them.
+                        for(int i = 0; i < count; i++)
+                        {
+                                LLPluginProcessParent *self = (LLPluginProcessParent *)(descriptors[i].client_data);
+                                // NOTE: the descriptor returned here is actually a COPY of the original (even though we create the pollset with APR_POLLSET_NOCOPY).
+                                // This means that even if the parent has set its mPollFD.client_data to NULL, the old pointer may still there in this descriptor.
+                                // It's even possible that the old pointer no longer points to a valid LLPluginProcessParent.
+                                // This means that we can't safely dereference the 'self' pointer here without some extra steps...
+                                if(self)
+                                {
+                                        // Make sure this pointer is still in the instances list
+                                        bool valid = false;
+                                        {
+                                                LLMutexLock lock(sInstancesMutex);
+                                                for(std::list<LLPluginProcessParent*>::iterator iter = sInstances.begin(); iter != sInstances.end(); ++iter)
+                                                {
+                                                        if(*iter == self)
+                                                        {
+                                                                // Lock the instance's mutex before unlocking the global mutex.  
+                                                                // This avoids a possible race condition where the instance gets deleted between this check and the servicePoll() call.
+                                                                self->mIncomingQueueMutex.lock();
+                                                                valid = true;
+                                                                break;
+                                                        }
+                                                }
+                                        }
+                                        
+                                        if(valid)
+                                        {
+                                                // The instance is still valid.
+                                                // Pull incoming messages off the socket
+                                                self->servicePoll();
+                                                self->mIncomingQueueMutex.unlock();
+                                        }
+                                        else
+                                        {
+                                                LL_DEBUGS("PluginPoll") << "detected deleted instance " << self << LL_ENDL;
+                                        }
+
+                                }
+                        }
+                }
+                else if(APR_STATUS_IS_TIMEUP(status))
+                {
+                        // timed out with no incoming data.  Just return.
+                }
+                else if(status == EBADF)
+                {
+                        // This happens when one of the file descriptors in the pollset is destroyed, which happens whenever a plugin's socket is closed.
+                        // The pollset has been or will be recreated, so just return.
+                        LL_DEBUGS("PluginPoll") << "apr_pollset_poll returned EBADF" << LL_ENDL;
+                }
+                else if(status != APR_SUCCESS)
+                {
+                        LL_WARNS("PluginPoll") << "apr_pollset_poll failed with status " << status << LL_ENDL;
+                }
+        }
+}
+
+void LLPluginProcessParent::servicePoll()
+{
+        bool result = true;
+        
+        // poll signalled on this object's socket.  Try to process incoming messages.
+        if(mMessagePipe)
+        {
+                result = mMessagePipe->pumpInput(0.0f);
+        }
+
+        if(!result)
+        {
+                // If we got a read error on input, remove this pipe from the pollset
+                apr_pollset_remove(sPollSet, &mPollFD);
+
+                // and tell the code not to re-add it
+                mPollFD.client_data = NULL;
+        }
+}
+
+void LLPluginProcessParent::receiveMessageRaw(const std::string &message)
+{
+        LL_DEBUGS("PluginParent") << "Received: " << message << LL_ENDL;
+
+        LLPluginMessage parsed;
+        if(parsed.parse(message) != -1)
+        {
+                if(parsed.hasValue("blocking_request"))
+                {
+                        mBlocked = true;
+                }
+
+                if(mPolledInput)
+                {
+                        // This is being called on the polling thread -- only do minimal processing/queueing.
+                        receiveMessageEarly(parsed);
+                }
+                else
+                {
+                        // This is not being called on the polling thread -- do full message processing at this time.
+                        receiveMessage(parsed);
+                }
+        }
+}
+
+void LLPluginProcessParent::receiveMessageEarly(const LLPluginMessage &message)
+{
+        // NOTE: this function will be called from the polling thread.  It will be called with mIncomingQueueMutex _already locked_. 
+
+        bool handled = false;
+        
+        std::string message_class = message.getClass();
+        if(message_class == LLPLUGIN_MESSAGE_CLASS_INTERNAL)
+        {
+                // no internal messages need to be handled early.
+        }
+        else
+        {
+                // Call out to the owner and see if they to reply
+                // TODO: Should this only happen when blocked?
+                if(mOwner != NULL)
+                {
+                        handled = mOwner->receivePluginMessageEarly(message);
+                }
+        }
+        
+        if(!handled)
+        {
+                // any message that wasn't handled early needs to be queued.
+                mIncomingQueue.push(message);
+        }
+}
+
+void LLPluginProcessParent::receiveMessage(const LLPluginMessage &message)
+{
+        std::string message_class = message.getClass();
+        if(message_class == LLPLUGIN_MESSAGE_CLASS_INTERNAL)
+        {
+                // internal messages should be handled here
+                std::string message_name = message.getName();
+                if(message_name == "hello")
+                {
+                        if(mState == STATE_CONNECTED)
+                        {
+                                // Plugin host has launched.  Tell it which plugin to load.
+                                setState(STATE_HELLO);
+                        }
+                        else
+                        {
+                                LL_WARNS("PluginParent") << "received hello message in wrong state -- bailing out" << LL_ENDL;
+                                errorState();
+                        }
+
+                }
+                else if(message_name == "load_plugin_response")
+                {
+                        if(mState == STATE_LOADING)
+                        {
+                                // Plugin has been loaded.
+
+                                mPluginVersionString = message.getValue("plugin_version");
+                                LL_INFOS("PluginParent") << "plugin version string: " << mPluginVersionString << LL_ENDL;
+
+                                // Check which message classes/versions the plugin supports.
+                                // TODO: check against current versions
+                                // TODO: kill plugin on major mismatches?
+                                mMessageClassVersions = message.getValueLLSD("versions");
+                                LLSD::map_iterator iter;
+                                for(iter = mMessageClassVersions.beginMap(); iter != mMessageClassVersions.endMap(); iter++)
+                                {
+                                        LL_INFOS("PluginParent") << "message class: " << iter->first << " -> version: " << iter->second.asString() << LL_ENDL;
+                                }
+
+                                // Send initial sleep time
+                                setSleepTime(mSleepTime, true);                 
+
+                                setState(STATE_RUNNING);
+                        }
+                        else
+                        {
+                                LL_WARNS("PluginParent") << "received load_plugin_response message in wrong state -- bailing out" << LL_ENDL;
+                                errorState();
+                        }
+                }
+                else if(message_name == "heartbeat")
+                {
+                        // this resets our timer.
+                        mHeartbeat.setTimerExpirySec(mPluginLockupTimeout);
+
+                        mCPUUsage = message.getValueReal("cpu_usage");
+
+                        LL_DEBUGS("PluginSpam") << "cpu usage reported as " << mCPUUsage << LL_ENDL;
+
+                }
+                else if(message_name == "shm_add_response")
+                {
+                        // Nothing to do here.
+                }
+                else if(message_name == "shm_remove_response")
+                {
+                        std::string name = message.getValue("name");
+                        sharedMemoryRegionsType::iterator iter = mSharedMemoryRegions.find(name);
+                        
+                        if(iter != mSharedMemoryRegions.end())
+                        {
+                                // destroy the shared memory region
+                                iter->second->destroy();
+                                
+                                // and remove it from our map
+                                mSharedMemoryRegions.erase(iter);
+                        }
+                }
+                else
+                {
+                        LL_WARNS("PluginParent") << "Unknown internal message from child: " << message_name << LL_ENDL;
+                }
+        }
+        else
+        {
+                if(mOwner != NULL)
+                {
+                        mOwner->receivePluginMessage(message);
+                }
+        }
+}
+
+std::string LLPluginProcessParent::addSharedMemory(size_t size)
+{
+        std::string name;
+        
+        LLPluginSharedMemory *region = new LLPluginSharedMemory;
+
+        // This is a new region
+        if(region->create(size))
+        {
+                name = region->getName();
+                
+                mSharedMemoryRegions.insert(sharedMemoryRegionsType::value_type(name, region));
+                
+                LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "shm_add");
+                message.setValue("name", name);
+                message.setValueS32("size", (S32)size);
+                sendMessage(message);
+        }
+        else
+        {
+                LL_WARNS("PluginParent") << "Couldn't create a shared memory segment!" << LL_ENDL;
+
+                // Don't leak
+                delete region;
+        }
+
+        return name;
+}
+
+void LLPluginProcessParent::removeSharedMemory(const std::string &name)
+{
+        sharedMemoryRegionsType::iterator iter = mSharedMemoryRegions.find(name);
+        
+        if(iter != mSharedMemoryRegions.end())
+        {
+                // This segment exists.  Send the message to the child to unmap it.  The response will cause the parent to unmap our end.
+                LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "shm_remove");
+                message.setValue("name", name);
+                sendMessage(message);
+        }
+        else
+        {
+                LL_WARNS("PluginParent") << "Request to remove an unknown shared memory segment." << LL_ENDL;
+        }
+}
+size_t LLPluginProcessParent::getSharedMemorySize(const std::string &name)
+{
+        size_t result = 0;
+        
+        sharedMemoryRegionsType::iterator iter = mSharedMemoryRegions.find(name);
+        if(iter != mSharedMemoryRegions.end())
+        {
+                result = iter->second->getSize();
+        }
+        
+        return result;
+}
+void *LLPluginProcessParent::getSharedMemoryAddress(const std::string &name)
+{
+        void *result = NULL;
+        
+        sharedMemoryRegionsType::iterator iter = mSharedMemoryRegions.find(name);
+        if(iter != mSharedMemoryRegions.end())
+        {
+                result = iter->second->getMappedAddress();
+        }
+        
+        return result;
+}
+
+std::string LLPluginProcessParent::getMessageClassVersion(const std::string &message_class)
+{
+        std::string result;
+        
+        if(mMessageClassVersions.has(message_class))
+        {
+                result = mMessageClassVersions[message_class].asString();
+        }
+        
+        return result;
+}
+
+std::string LLPluginProcessParent::getPluginVersion(void)
+{
+        return mPluginVersionString;
+}
+
+void LLPluginProcessParent::setState(EState state)
+{
+        LL_DEBUGS("PluginParent") << "setting state to " << stateToString(state) << LL_ENDL;
+        mState = state;
+};
+
+bool LLPluginProcessParent::pluginLockedUpOrQuit()
+{
+        bool result = false;
+
+        if(!mProcess.isRunning())
+        {
+                LL_WARNS("PluginParent") << "child exited" << LL_ENDL;
+                result = true;
+        }
+        else if(pluginLockedUp())
+        {
+                LL_WARNS("PluginParent") << "timeout" << LL_ENDL;
+                result = true;
+        }
+
+        return result;
+}
+
+bool LLPluginProcessParent::pluginLockedUp()
+{
+        if(mDisableTimeout || mDebug || mBlocked)
+        {
+                // Never time out a plugin process in these cases.
+                return false;
+        }
+        
+        // If the timer is running and has expired, the plugin has locked up.
+        return (mHeartbeat.getStarted() && mHeartbeat.hasExpired());
+}
+
+std::string LLPluginProcessParent::stateToString(EState state)
+{
+        std::string eng = "unknown plugin state";
+        switch (state)
+        {
+        case STATE_UNINITIALIZED:
+                eng = "STATE_UNINITIALIZED";
+                break;
+        case STATE_INITIALIZED: 
+                eng = "STATE_INITIALIZED - init() has been called";
+                break;
+        case STATE_LISTENING:
+                eng = "STATE_LISTENING - listening for incoming connection";
+                break;
+        case STATE_LAUNCHED:
+                eng = "STATE_LAUNCHED - process has been launched";
+                break;
+        case STATE_CONNECTED:
+                eng = "STATE_CONNECTED - process has connected";
+                break;
+        case STATE_HELLO:
+                eng = "STATE_HELLO - first message from the plugin process has been received";
+                break;
+        case STATE_LOADING:
+                eng = "STATE_LOADING - process has been asked to load the plugin";
+                break;
+        case STATE_RUNNING:
+                eng = "STATE_RUNNING - plugin running";
+                break;
+        case STATE_LAUNCH_FAILURE:
+                eng = "STATE_LAUNCH_FAILURE - failure before plugin loaded";
+                break;
+        case STATE_ERROR:
+                eng = "STATE_ERROR - generic bailout state";
+                break;
+        case STATE_CLEANUP:
+                eng = "STATE_CLEANUP - clean everything up";
+                break;
+        case STATE_EXITING:
+                eng = "STATE_EXITING - tried to kill process, waiting for it to exit";
+                break;
+        case STATE_DONE:
+                eng = "STATE_DONE - plugin done";
+                break;
+        default:
+                break;
+        }
+        
+        return llformat("(%d) ", (S32)state) + eng;
+}
diff --git a/linden/indra/llplugin/llpluginprocessparent.h b/linden/indra/llplugin/llpluginprocessparent.h
new file mode 100755
index 0000000..bba3643
--- /dev/null
+++ b/linden/indra/llplugin/llpluginprocessparent.h
@@ -0,0 +1,204 @@
+/** 
+ * @file llpluginprocessparent.h
+ * @brief LLPluginProcessParent handles the parent side of the external-process plugin API.
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+#ifndef LL_LLPLUGINPROCESSPARENT_H
+#define LL_LLPLUGINPROCESSPARENT_H
+
+#include <queue> //imprudence
+
+#include "llapr.h"
+#include "llprocesslauncher.h"
+#include "llpluginmessage.h"
+#include "llpluginmessagepipe.h"
+#include "llpluginsharedmemory.h"
+
+#include "lliosocket.h"
+#include "llthread.h"
+
+class LLPluginProcessParentOwner
+{
+public:
+        virtual ~LLPluginProcessParentOwner();
+        virtual void receivePluginMessage(const LLPluginMessage &message) = 0;
+        virtual bool receivePluginMessageEarly(const LLPluginMessage &message) {return false;};
+        // This will only be called when the plugin has died unexpectedly 
+        virtual void pluginLaunchFailed() {};
+        virtual void pluginDied() {};
+};
+
+class LLPluginProcessParent : public LLPluginMessagePipeOwner
+{
+        LOG_CLASS(LLPluginProcessParent);
+public:
+        LLPluginProcessParent(LLPluginProcessParentOwner *owner);
+        ~LLPluginProcessParent();
+                
+        void init(const std::string &launcher_filename, 
+                          const std::string &plugin_filename, 
+                          bool debug);
+
+        void idle(void);
+        
+        // returns true if the plugin is on its way to steady state
+        bool isLoading(void);
+
+        // returns true if the plugin is in the steady state (processing messages)
+        bool isRunning(void);
+
+        // returns true if the process has exited or we've had a fatal error
+        bool isDone(void);      
+        
+        // returns true if the process is currently waiting on a blocking request
+        bool isBlocked(void) { return mBlocked; };
+        
+        void killSockets(void);
+        
+        // Go to the proper error state
+        void errorState(void);
+
+        void setSleepTime(F64 sleep_time, bool force_send = false);
+        F64 getSleepTime(void) const { return mSleepTime; };
+
+        void sendMessage(const LLPluginMessage &message);
+        
+        void receiveMessage(const LLPluginMessage &message);
+        
+        // Inherited from LLPluginMessagePipeOwner
+        /*virtual*/ void receiveMessageRaw(const std::string &message);
+        /*virtual*/ void receiveMessageEarly(const LLPluginMessage &message);
+        /*virtual*/ void setMessagePipe(LLPluginMessagePipe *message_pipe) ;
+        
+        // This adds a memory segment shared with the client, generating a name for the segment.  The name generated is guaranteed to be unique on the host.
+        // The caller must call removeSharedMemory first (and wait until getSharedMemorySize returns 0 for the indicated name) before re-adding a segment with the same name.
+        std::string addSharedMemory(size_t size);
+        // Negotiates for the removal of a shared memory segment.  It is the caller's responsibility to ensure that nothing touches the memory
+        // after this has been called, since the segment will be unmapped shortly thereafter.
+        void removeSharedMemory(const std::string &name);
+        size_t getSharedMemorySize(const std::string &name);
+        void *getSharedMemoryAddress(const std::string &name);
+        
+        // Returns the version string the plugin indicated for the message class, or an empty string if that class wasn't in the list.
+        std::string getMessageClassVersion(const std::string &message_class);
+
+        std::string getPluginVersion(void);
+        
+        bool getDisableTimeout() { return mDisableTimeout; };
+        void setDisableTimeout(bool disable) { mDisableTimeout = disable; };
+        
+        void setLaunchTimeout(F32 timeout) { mPluginLaunchTimeout = timeout; };
+        void setLockupTimeout(F32 timeout) { mPluginLockupTimeout = timeout; };
+
+        F64 getCPUUsage() { return mCPUUsage; };
+        
+        static void poll(F64 timeout);
+        static bool canPollThreadRun() { return (sPollSet || sPollsetNeedsRebuild || sUseReadThread); };
+        static void setUseReadThread(bool use_read_thread);
+        static bool getUseReadThread() { return sUseReadThread; };
+private:
+
+        enum EState
+        {
+                STATE_UNINITIALIZED,
+                STATE_INITIALIZED,              // init() has been called
+                STATE_LISTENING,                // listening for incoming connection
+                STATE_LAUNCHED,                 // process has been launched
+                STATE_CONNECTED,                // process has connected
+                STATE_HELLO,                    // first message from the plugin process has been received
+                STATE_LOADING,                  // process has been asked to load the plugin
+                STATE_RUNNING,                  // 
+                STATE_LAUNCH_FAILURE,   // Failure before plugin loaded
+                STATE_ERROR,                    // generic bailout state
+                STATE_CLEANUP,                  // clean everything up
+                STATE_EXITING,                  // Tried to kill process, waiting for it to exit
+                STATE_DONE                              //
+
+        };
+        EState mState;
+        void setState(EState state);
+        std::string stateToString(EState state);
+        
+        bool pluginLockedUp();
+        bool pluginLockedUpOrQuit();
+
+        bool accept();
+                
+        LLSocket::ptr_t mListenSocket;
+        LLSocket::ptr_t mSocket;
+        U32 mBoundPort;
+        
+        LLProcessLauncher mProcess;
+        
+        std::string mPluginFile;
+
+        LLPluginProcessParentOwner *mOwner;
+        
+        typedef std::map<std::string, LLPluginSharedMemory*> sharedMemoryRegionsType;
+        sharedMemoryRegionsType mSharedMemoryRegions;
+        
+        LLSD mMessageClassVersions;
+        std::string mPluginVersionString;
+        
+        LLTimer mHeartbeat;
+        F64             mSleepTime;
+        F64             mCPUUsage;
+        
+        bool mDisableTimeout;
+        bool mDebug;
+        bool mBlocked;
+        bool mPolledInput;
+
+        LLProcessLauncher mDebugger;
+        
+        F32 mPluginLaunchTimeout;               // Somewhat longer timeout for initial launch.
+        F32 mPluginLockupTimeout;               // If we don't receive a heartbeat in this many seconds, we declare the plugin locked up.
+
+        static bool sUseReadThread;
+        apr_pollfd_t mPollFD;
+        AIAPRPool mPollFDPool;
+        static apr_pollset_t *sPollSet;
+    static AIAPRPool sPollSetPool;
+        static bool sPollsetNeedsRebuild;
+        static LLMutex *sInstancesMutex;
+        static std::list<LLPluginProcessParent*> sInstances;
+        static void dirtyPollSet();
+        static void updatePollset();
+        void servicePoll();
+        static LLThread *sReadThread;
+        
+        LLMutex mIncomingQueueMutex;
+        std::queue<LLPluginMessage> mIncomingQueue;
+};
+
+#endif // LL_LLPLUGINPROCESSPARENT_H
diff --git a/linden/indra/llplugin/llpluginsharedmemory.cpp b/linden/indra/llplugin/llpluginsharedmemory.cpp
new file mode 100755
index 0000000..882a2a1
--- /dev/null
+++ b/linden/indra/llplugin/llpluginsharedmemory.cpp
@@ -0,0 +1,522 @@
+/** 
+ * @file llpluginsharedmemory.cpp
+ * LLPluginSharedMemory manages a shared memory segment for use by the LLPlugin API.
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+/// IMPRUDENCE: this is part of the viewer and the SLPlugin
+
+#include "linden_common.h"
+
+#include "llpluginsharedmemory.h"
+
+#if LL_WINDOWS
+#include <process.h>
+#else // LL_WINDOWS
+#include <sys/types.h>
+#include <unistd.h>
+#endif // LL_WINDOWS
+
+// on Mac and Linux, we use the native shm_open/mmap interface by using
+//      #define USE_SHM_OPEN_SHARED_MEMORY 1
+// in the appropriate sections below.
+
+// For Windows, use:
+//      #define USE_WIN32_SHARED_MEMORY 1
+
+// If we ever want to fall back to the apr implementation for a platform, use:
+//      #define USE_APR_SHARED_MEMORY 1
+
+#if LL_WINDOWS
+//      #define USE_APR_SHARED_MEMORY 1
+        #define USE_WIN32_SHARED_MEMORY 1
+#elif LL_DARWIN
+        #define USE_SHM_OPEN_SHARED_MEMORY 1
+#elif LL_LINUX
+        #define USE_SHM_OPEN_SHARED_MEMORY 1
+#endif
+
+
+// FIXME: This path thing is evil and unacceptable.
+#if LL_WINDOWS
+        #define APR_SHARED_MEMORY_PREFIX_STRING "C:\\LLPlugin_"
+        // Apparnently using the "Global\\" prefix here only works from administrative accounts under Vista.
+        // Other options I've seen referenced are "Local\\" and "Session\\".
+        #define WIN32_SHARED_MEMORY_PREFIX_STRING "Local\\LL_"
+#else
+        // mac and linux
+        #define APR_SHARED_MEMORY_PREFIX_STRING "/tmp/LLPlugin_"
+        #define SHM_OPEN_SHARED_MEMORY_PREFIX_STRING "/LL"
+#endif
+
+#if USE_APR_SHARED_MEMORY 
+        #include "llapr.h"
+        #include "apr_shm.h"
+#elif USE_SHM_OPEN_SHARED_MEMORY
+        #include <sys/fcntl.h>
+        #include <sys/mman.h>
+        #include <errno.h>
+#elif USE_WIN32_SHARED_MEMORY
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
+#include <windows.h>
+#endif // USE_APR_SHARED_MEMORY
+
+int LLPluginSharedMemory::sSegmentNumber = 0;
+
+std::string LLPluginSharedMemory::createName(void)
+{
+        std::stringstream newname;
+
+#if LL_WINDOWS
+        newname << GetCurrentProcessId();
+#else // LL_WINDOWS
+        newname << getpid();
+#endif // LL_WINDOWS
+                
+        newname << "_" << sSegmentNumber++;
+        
+        return newname.str();
+}
+
+/**
+ * @brief LLPluginSharedMemoryImpl is the platform-dependent implementation of LLPluginSharedMemory. TODO:DOC is this necessary/sufficient? kinda obvious.
+ *
+ */
+class LLPluginSharedMemoryPlatformImpl
+{
+public:
+        LLPluginSharedMemoryPlatformImpl();
+        ~LLPluginSharedMemoryPlatformImpl();
+        
+#if USE_APR_SHARED_MEMORY
+        apr_shm_t* mAprSharedMemory;    
+#elif USE_SHM_OPEN_SHARED_MEMORY
+        int mSharedMemoryFD;
+#elif USE_WIN32_SHARED_MEMORY
+        HANDLE mMapFile;
+#endif
+
+};
+
+/**
+ * Constructor. Creates a shared memory segment.
+ */
+LLPluginSharedMemory::LLPluginSharedMemory()
+{
+        mSize = 0;
+        mMappedAddress = NULL;
+        mNeedsDestroy = false;
+
+        mImpl = new LLPluginSharedMemoryPlatformImpl;
+}
+
+/**
+ * Destructor. Uses destroy() and detach() to ensure shared memory segment is cleaned up.
+ */
+LLPluginSharedMemory::~LLPluginSharedMemory()
+{
+        if(mNeedsDestroy)
+                destroy();
+        else
+                detach();
+                
+        unlink();
+        
+        delete mImpl;
+}
+
+#if USE_APR_SHARED_MEMORY
+// MARK: apr implementation
+
+LLPluginSharedMemoryPlatformImpl::LLPluginSharedMemoryPlatformImpl()
+{
+        mAprSharedMemory = NULL;
+}
+
+LLPluginSharedMemoryPlatformImpl::~LLPluginSharedMemoryPlatformImpl()
+{
+        
+}
+
+bool LLPluginSharedMemory::map(void)
+{
+        mMappedAddress = apr_shm_baseaddr_get(mImpl->mAprSharedMemory);
+        if(mMappedAddress == NULL)
+        {
+                return false;
+        }
+        
+        return true;
+}
+
+bool LLPluginSharedMemory::unmap(void)
+{
+        // This is a no-op under apr.
+        return true;
+}
+
+bool LLPluginSharedMemory::close(void)
+{
+        // This is a no-op under apr.
+        return true;
+}
+
+bool LLPluginSharedMemory::unlink(void)
+{
+        // This is a no-op under apr.
+        return true;
+}
+
+
+bool LLPluginSharedMemory::create(size_t size)
+{
+        mName = APR_SHARED_MEMORY_PREFIX_STRING;
+        mName += createName();
+        mSize = size;
+        
+        mPool.create();
+        apr_status_t status = apr_shm_create( &(mImpl->mAprSharedMemory), mSize, mName.c_str(), mPool());
+        
+        if(ll_apr_warn_status(status))
+        {
+                return false;
+        }
+
+        mNeedsDestroy = true;
+        
+        return map();
+}
+
+bool LLPluginSharedMemory::destroy(void)
+{
+        if(mImpl->mAprSharedMemory)
+        {
+                apr_status_t status = apr_shm_destroy(mImpl->mAprSharedMemory);
+                if(ll_apr_warn_status(status))
+                {
+                        // TODO: Is this a fatal error?  I think not...
+                }
+                mImpl->mAprSharedMemory = NULL;
+        }
+        mPool.destroy();
+        return true;
+}
+
+bool LLPluginSharedMemory::attach(const std::string &name, size_t size)
+{
+        mName = name;
+        mSize = size;
+        
+        mPool.create();
+        apr_status_t status = apr_shm_attach( &(mImpl->mAprSharedMemory), mName.c_str(), mPool() );
+        
+        if(ll_apr_warn_status(status))
+        {
+                return false;
+        }
+
+        return map();
+}
+
+
+bool LLPluginSharedMemory::detach(void)
+{
+        if(mImpl->mAprSharedMemory)
+        {
+                apr_status_t status = apr_shm_detach(mImpl->mAprSharedMemory);
+                if(ll_apr_warn_status(status))
+                {
+                        // TODO: Is this a fatal error?  I think not...
+                }
+                mImpl->mAprSharedMemory = NULL;
+        }
+        mPool.destroy();
+        
+        return true;
+}
+
+
+#elif USE_SHM_OPEN_SHARED_MEMORY
+// MARK: shm_open/mmap implementation
+
+LLPluginSharedMemoryPlatformImpl::LLPluginSharedMemoryPlatformImpl()
+{
+        mSharedMemoryFD = -1;
+}
+
+LLPluginSharedMemoryPlatformImpl::~LLPluginSharedMemoryPlatformImpl()
+{
+}
+
+bool LLPluginSharedMemory::map(void)
+{
+        mMappedAddress = ::mmap(NULL, mSize, PROT_READ | PROT_WRITE, MAP_SHARED, mImpl->mSharedMemoryFD, 0);
+        if(mMappedAddress == NULL)
+        {
+                return false;
+        }
+        
+        LL_DEBUGS("Plugin") << "memory mapped at " << mMappedAddress << LL_ENDL;
+
+        return true;
+}
+
+bool LLPluginSharedMemory::unmap(void)
+{
+        if(mMappedAddress != NULL)
+        {
+                LL_DEBUGS("Plugin") << "calling munmap(" << mMappedAddress << ", " << mSize << ")" << LL_ENDL;
+                if(::munmap(mMappedAddress, mSize) == -1)       
+                {
+                        // TODO: Is this a fatal error?  I think not...
+                }
+                
+                mMappedAddress = NULL;
+        }
+
+        return true;
+}
+
+bool LLPluginSharedMemory::close(void)
+{
+        if(mImpl->mSharedMemoryFD != -1)
+        {
+                LL_DEBUGS("Plugin") << "calling close(" << mImpl->mSharedMemoryFD << ")" << LL_ENDL;
+                if(::close(mImpl->mSharedMemoryFD) == -1)
+                {
+                        // TODO: Is this a fatal error?  I think not...
+                }
+                
+                mImpl->mSharedMemoryFD = -1;
+        }
+        return true;
+}
+
+bool LLPluginSharedMemory::unlink(void)
+{
+        if(!mName.empty())
+        {
+                if(::shm_unlink(mName.c_str()) == -1)
+                {
+                        return false;
+                }
+        }
+                
+        return true;
+}
+
+
+bool LLPluginSharedMemory::create(size_t size)
+{
+        mName = SHM_OPEN_SHARED_MEMORY_PREFIX_STRING;
+        mName += createName();
+        mSize = size;
+        
+        // Preemptive unlink, just in case something didn't get cleaned up.
+        unlink();
+
+        mImpl->mSharedMemoryFD = ::shm_open(mName.c_str(), O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
+        if(mImpl->mSharedMemoryFD == -1)
+        {
+                return false;
+        }
+        
+        mNeedsDestroy = true;
+        
+        if(::ftruncate(mImpl->mSharedMemoryFD, mSize) == -1)
+        {
+                return false;
+        }
+        
+        
+        return map();
+}
+
+bool LLPluginSharedMemory::destroy(void)
+{
+        unmap();
+        close();        
+        
+        return true;
+}
+
+
+bool LLPluginSharedMemory::attach(const std::string &name, size_t size)
+{
+        mName = name;
+        mSize = size;
+
+        mImpl->mSharedMemoryFD = ::shm_open(mName.c_str(), O_RDWR, S_IRUSR | S_IWUSR);
+        if(mImpl->mSharedMemoryFD == -1)
+        {
+                return false;
+        }
+        
+        // unlink here so the segment will be cleaned up automatically after the last close.
+        unlink();
+        
+        return map();
+}
+
+bool LLPluginSharedMemory::detach(void)
+{
+        unmap();
+        close();        
+        return true;
+}
+
+#elif USE_WIN32_SHARED_MEMORY
+// MARK: Win32 CreateFileMapping-based implementation
+
+// Reference: http://msdn.microsoft.com/en-us/library/aa366551(VS.85).aspx
+
+LLPluginSharedMemoryPlatformImpl::LLPluginSharedMemoryPlatformImpl()
+{
+        mMapFile = NULL;
+}
+
+LLPluginSharedMemoryPlatformImpl::~LLPluginSharedMemoryPlatformImpl()
+{
+        
+}
+
+bool LLPluginSharedMemory::map(void)
+{
+        mMappedAddress = MapViewOfFile(
+                mImpl->mMapFile,                        // handle to map object
+                FILE_MAP_ALL_ACCESS,            // read/write permission
+                0,                   
+                0,                   
+                mSize);
+                
+        if(mMappedAddress == NULL)
+        {
+                LL_WARNS("Plugin") << "MapViewOfFile failed: " << GetLastError() << LL_ENDL;
+                return false;
+        }
+        
+        LL_DEBUGS("Plugin") << "memory mapped at " << mMappedAddress << LL_ENDL;
+
+        return true;
+}
+
+bool LLPluginSharedMemory::unmap(void)
+{
+        if(mMappedAddress != NULL)
+        {
+                UnmapViewOfFile(mMappedAddress);        
+                mMappedAddress = NULL;
+        }
+
+        return true;
+}
+
+bool LLPluginSharedMemory::close(void)
+{
+        if(mImpl->mMapFile != NULL)
+        {
+                CloseHandle(mImpl->mMapFile);
+                mImpl->mMapFile = NULL;
+        }
+        
+        return true;
+}
+
+bool LLPluginSharedMemory::unlink(void)
+{
+        // This is a no-op on Windows.
+        return true;
+}
+
+
+bool LLPluginSharedMemory::create(size_t size)
+{
+        mName = WIN32_SHARED_MEMORY_PREFIX_STRING;
+        mName += createName();
+        mSize = size;
+
+        mImpl->mMapFile = CreateFileMappingA(
+                 INVALID_HANDLE_VALUE,          // use paging file
+                 NULL,                                          // default security 
+                 PAGE_READWRITE,                        // read/write access
+                 0,                                                     // max. object size 
+                 mSize,                                         // buffer size  
+                 mName.c_str());                        // name of mapping object
+
+        if(mImpl->mMapFile == NULL)
+        {
+                LL_WARNS("Plugin") << "CreateFileMapping failed: " << GetLastError() << LL_ENDL;
+                return false;
+        }
+
+        mNeedsDestroy = true;
+                
+        return map();
+}
+
+bool LLPluginSharedMemory::destroy(void)
+{
+        unmap();
+        close();
+        return true;
+}
+
+bool LLPluginSharedMemory::attach(const std::string &name, size_t size)
+{
+        mName = name;
+        mSize = size;
+
+        mImpl->mMapFile = OpenFileMappingA(
+                                FILE_MAP_ALL_ACCESS,            // read/write access
+                                FALSE,                                          // do not inherit the name
+                                mName.c_str());                         // name of mapping object
+        
+        if(mImpl->mMapFile == NULL)
+        {
+                LL_WARNS("Plugin") << "OpenFileMapping failed: " << GetLastError() << LL_ENDL;
+                return false;
+        }
+                
+        return map();
+}
+
+bool LLPluginSharedMemory::detach(void)
+{
+        unmap();
+        close();
+        return true;
+}
+
+
+
+#endif
diff --git a/linden/indra/llplugin/llpluginsharedmemory.h b/linden/indra/llplugin/llpluginsharedmemory.h
new file mode 100755
index 0000000..669a3e4
--- /dev/null
+++ b/linden/indra/llplugin/llpluginsharedmemory.h
@@ -0,0 +1,135 @@
+/** 
+ * @file llpluginsharedmemory.h
+ *
+ * @cond
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ * @endcond
+ */
+
+#ifndef LL_LLPLUGINSHAREDMEMORY_H
+#define LL_LLPLUGINSHAREDMEMORY_H
+
+#include "aiaprpool.h"
+
+class LLPluginSharedMemoryPlatformImpl;
+
+/**
+ * @brief LLPluginSharedMemory manages a shared memory segment for use by the LLPlugin API.
+ *
+ */
+class LLPluginSharedMemory
+{
+        LOG_CLASS(LLPluginSharedMemory);
+public:
+        LLPluginSharedMemory();
+        ~LLPluginSharedMemory();
+        
+        // Parent will use create/destroy, child will use attach/detach.
+        // Message transactions will ensure child attaches after parent creates and detaches before parent destroys.
+        
+   /** 
+    * Creates a shared memory segment, with a name which is guaranteed to be unique on the host at the current time. Used by parent.
+    * Message transactions will (? TODO:DOC - should? must?) ensure child attaches after parent creates and detaches before parent destroys.
+    *
+    * @param[in] size Shared memory size in TODO:DOC units = bytes?.
+    *
+    * @return False for failure, true for success.
+    */
+        bool create(size_t size);
+   /** 
+    * Destroys a shared memory segment. Used by parent.
+    * Message transactions will (? TODO:DOC - should? must?) ensure child attaches after parent creates and detaches before parent destroys.
+    *
+    * @return True. TODO:DOC - always returns true. Is this the intended behavior?
+    */
+        bool destroy(void);
+        
+   /** 
+    * Creates and attaches a name to a shared memory segment. TODO:DOC what's the difference between attach() and create()?
+    *
+    * @param[in] name Name to attach to memory segment
+    * @param[in] size Size of memory segment TODO:DOC in bytes?
+    *
+    * @return False on failure, true otherwise.
+    */
+        bool attach(const std::string &name, size_t size);
+   /** 
+    * Detaches shared memory segment.
+    *
+    * @return False on failure, true otherwise.
+    */
+        bool detach(void);
+
+   /** 
+    * Checks if shared memory is mapped to a non-null address.
+    *
+    * @return True if memory address is non-null, false otherwise.
+    */
+        bool isMapped(void) const { return (mMappedAddress != NULL); };
+   /** 
+    * Get pointer to shared memory.
+    *
+    * @return Pointer to shared memory.
+    */
+        void *getMappedAddress(void) const { return mMappedAddress; };
+   /** 
+    * Get size of shared memory.
+    *
+    * @return Size of shared memory in bytes. TODO:DOC are bytes the correct unit?
+    */
+        size_t getSize(void) const { return mSize; };
+   /** 
+    * Get name of shared memory.
+    *
+    * @return Name of shared memory.
+    */
+        std::string getName() const { return mName; };
+        
+private:
+        bool map(void);
+        bool unmap(void);
+        bool close(void);
+        bool unlink(void);
+        
+        AIAPRPool mPool;
+        std::string mName;
+        size_t mSize;
+        void *mMappedAddress;
+        bool mNeedsDestroy;
+        
+        LLPluginSharedMemoryPlatformImpl *mImpl;
+        
+        static int sSegmentNumber;
+        static std::string createName();
+        
+};
+
+
+
+#endif // LL_LLPLUGINSHAREDMEMORY_H
diff --git a/linden/indra/llplugin/slplugin/CMakeLists.txt b/linden/indra/llplugin/slplugin/CMakeLists.txt
new file mode 100755
index 0000000..81d9299
--- /dev/null
+++ b/linden/indra/llplugin/slplugin/CMakeLists.txt
@@ -0,0 +1,82 @@
+project(SLPlugin)
+
+include(00-Common)
+include(LLCommon)
+include(LLPlugin)
+include(Linking)
+include(PluginAPI)
+include(LLMessage)
+
+include_directories(
+    ${LLPLUGIN_INCLUDE_DIRS}
+    ${LLMESSAGE_INCLUDE_DIRS}
+    ${LLCOMMON_INCLUDE_DIRS}
+)
+
+if (DARWIN)
+    include(CMakeFindFrameworks)
+    find_library(CARBON_LIBRARY Carbon)
+    find_library(COCOA_LIBRARY Cocoa)
+endif (DARWIN)
+
+
+### SLPlugin
+
+set(SLPlugin_SOURCE_FILES
+    slplugin.cpp
+    )
+
+if (DARWIN)
+  list(APPEND SLPlugin_SOURCE_FILES
+    slplugin-objc.mm
+  )
+  list(APPEND SLPlugin_HEADER_FILES
+    slplugin-objc.h
+  )
+endif (DARWIN)
+
+set_source_files_properties(${SLPlugin_HEADER_FILES}
+                            PROPERTIES HEADER_FILE_ONLY TRUE)
+
+if (SLPlugin_HEADER_FILES)
+  list(APPEND SLPlugin_SOURCE_FILES ${SLPlugin_HEADER_FILES})
+endif (SLPlugin_HEADER_FILES)
+
+add_executable(SLPlugin
+    WIN32
+    MACOSX_BUNDLE
+    ${SLPlugin_SOURCE_FILES}
+)
+
+set_target_properties(SLPlugin
+  PROPERTIES
+  MACOSX_BUNDLE_INFO_PLIST ${CMAKE_CURRENT_SOURCE_DIR}/slplugin_info.plist
+  )
+
+target_link_libraries(SLPlugin
+  ${LLPLUGIN_LIBRARIES}
+  ${LLMESSAGE_LIBRARIES}
+  ${LLCOMMON_LIBRARIES}
+  ${PLUGIN_API_WINDOWS_LIBRARIES}
+)
+
+add_dependencies(SLPlugin
+  ${LLPLUGIN_LIBRARIES}
+  ${LLMESSAGE_LIBRARIES}
+  ${LLCOMMON_LIBRARIES}
+)
+
+if (DARWIN)
+  # Mac version needs to link against Carbon
+  target_link_libraries(SLPlugin ${CARBON_LIBRARY} ${COCOA_LIBRARY})
+  # Make sure the app bundle has a Resources directory (it will get populated by viewer-manifest.py later)
+  add_custom_command(
+    TARGET SLPlugin POST_BUILD
+    COMMAND mkdir
+    ARGS
+      -p
+      ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/SLPlugin.app/Contents/Resources
+  )
+endif (DARWIN)
+
+#ll_deploy_sharedlibs_command(SLPlugin)
diff --git a/linden/indra/llplugin/slplugin/slplugin-objc.h b/linden/indra/llplugin/slplugin/slplugin-objc.h
new file mode 100644
index 0000000..42029e4
--- /dev/null
+++ b/linden/indra/llplugin/slplugin/slplugin-objc.h
@@ -0,0 +1,42 @@
+/**
+ * @file slplugin-objc.h
+ * @brief Header file for slplugin-objc.mm.
+ *
+ * @cond
+ *
+ * $LicenseInfo:firstyear=2010&license=viewergpl$
+ * 
+ * Copyright (c) 2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ *
+ * @endcond
+ */
+
+
+/* Defined in slplugin-objc.mm: */
+void setupCocoa();
+void createAutoReleasePool();
+void deleteAutoReleasePool();
diff --git a/linden/indra/llplugin/slplugin/slplugin-objc.mm b/linden/indra/llplugin/slplugin/slplugin-objc.mm
new file mode 100644
index 0000000..125b264
--- /dev/null
+++ b/linden/indra/llplugin/slplugin/slplugin-objc.mm
@@ -0,0 +1,89 @@
+/**
+ * @file slplugin-objc.mm
+ * @brief Objective-C++ file for use with the loader shell, so we can use a couple of Cocoa APIs.
+ *
+ * @cond
+ *
+ * $LicenseInfo:firstyear=2010&license=viewergpl$
+ * 
+ * Copyright (c) 2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ *
+ * @endcond
+ */
+
+
+#include <AppKit/AppKit.h>
+
+#include "slplugin-objc.h"
+
+
+void setupCocoa()
+{
+        static bool inited = false;
+        
+        if(!inited)
+        {
+                createAutoReleasePool();
+                
+                // The following prevents the Cocoa command line parser from trying to open 'unknown' arguements as documents.
+                // ie. running './secondlife -set Language fr' would cause a pop-up saying can't open document 'fr' 
+                // when init'ing the Cocoa App window.          
+                [[NSUserDefaults standardUserDefaults] setObject:@"NO" forKey:@"NSTreatUnknownArgumentsAsOpen"];
+                
+                // This is a bit of voodoo taken from the Apple sample code "CarbonCocoa_PictureCursor":
+                //   http://developer.apple.com/samplecode/CarbonCocoa_PictureCursor/index.html
+                
+                //      Needed for Carbon based applications which call into Cocoa
+                NSApplicationLoad();
+
+                //      Must first call [[[NSWindow alloc] init] release] to get the NSWindow machinery set up so that NSCursor can use a window to cache the cursor image
+                [[[NSWindow alloc] init] release];
+                
+                deleteAutoReleasePool();
+                
+                inited = true;
+        }
+}
+
+static NSAutoreleasePool *sPool = NULL;
+
+void createAutoReleasePool()
+{
+        if(!sPool)
+        {
+                sPool = [[NSAutoreleasePool alloc] init];
+        }
+}
+
+void deleteAutoReleasePool()
+{
+        if(sPool)
+        {
+                [sPool release];
+                sPool = NULL;
+        }
+}
diff --git a/linden/indra/llplugin/slplugin/slplugin.cpp b/linden/indra/llplugin/slplugin/slplugin.cpp
new file mode 100755
index 0000000..4ef24a2
--- /dev/null
+++ b/linden/indra/llplugin/slplugin/slplugin.cpp
@@ -0,0 +1,439 @@
+/**
+ * @file slplugin.cpp
+ * @brief Loader shell for plugins, intended to be launched by the plugin host application, which directly loads a plugin dynamic library.
+ *
+ * @cond
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ * 
+ *
+ * @endcond
+ */
+
+/// IMPRUDENCE: this is part of the SLPlugin
+
+#include "linden_common.h"
+
+#include "llpluginprocesschild.h"
+#include "llpluginmessage.h"
+#include "llerrorcontrol.h"
+#include "llapr.h"
+#include "llstring.h"
+
+#if LL_DARWIN
+        #include <Carbon/Carbon.h>
+        #include "slplugin-objc.h"
+#endif
+
+#if LL_DARWIN || LL_LINUX
+        #include <signal.h>
+#endif
+
+//imprudence: or we include lldir, or use apache runtime
+//though the one is probably bloat and the other we rather want to avoid
+#include <stdio.h>  // FILENAME_MAX
+#ifdef LL_WINDOWS
+    #include <direct.h>
+    #define getImpruDir _getcwd
+    #define DIR_DELIMITER "\\"
+#else
+    #include <unistd.h>
+    #define getImpruDir getcwd
+    #define DIR_DELIMITER "/"
+#endif
+
+
+/*
+        On Mac OS, since we call WaitNextEvent, this process will show up in the dock unless we set the LSBackgroundOnly or LSUIElement flag in the Info.plist.
+
+        Normally non-bundled binaries don't have an info.plist file, but it's possible to embed one in the binary by adding this to the linker flags:
+
+        -sectcreate __TEXT __info_plist /path/to/slplugin_info.plist
+
+        which means adding this to the gcc flags:
+
+        -Wl,-sectcreate,__TEXT,__info_plist,/path/to/slplugin_info.plist
+        
+        Now that SLPlugin is a bundled app on the Mac, this is no longer necessary (it can just use a regular Info.plist file), but I'm leaving this comment in for posterity.
+*/
+
+#if LL_DARWIN || LL_LINUX
+// Signal handlers to make crashes not show an OS dialog...
+static void crash_handler(int sig)
+{
+        // Just exit cleanly.
+        // TODO: add our own crash reporting
+        _exit(1);
+}
+#endif
+
+#if LL_WINDOWS
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
+#include <windows.h>
+////////////////////////////////////////////////////////////////////////////////
+//      Our exception handler - will probably just exit and the host application
+//      will miss the heartbeat and log the error in the usual fashion.
+LONG WINAPI myWin32ExceptionHandler( struct _EXCEPTION_POINTERS* exception_infop )
+{
+        //std::cerr << "This plugin (" << __FILE__ << ") - ";
+        //std::cerr << "intercepted an unhandled exception and will exit immediately." << std::endl;
+
+        // TODO: replace exception handler before we exit?
+        return EXCEPTION_EXECUTE_HANDLER;
+}
+
+// Taken from : http://blog.kalmbachnet.de/?postid=75
+// The MSVC 2005 CRT forces the call of the default-debugger (normally Dr.Watson)
+// even with the other exception handling code. This (terrifying) piece of code
+// patches things so that doesn't happen.
+LPTOP_LEVEL_EXCEPTION_FILTER WINAPI MyDummySetUnhandledExceptionFilter(
+        LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter )
+{
+        return NULL;
+}
+
+BOOL PreventSetUnhandledExceptionFilter()
+{
+// WARNING: This won't work on 64-bit Windows systems so we turn it off it.
+//          It should work for any flavor of 32-bit Windows we care about.
+//          If it's off, sometimes you will see an OS message when a plugin crashes
+#ifndef _WIN64
+        HMODULE hKernel32 = LoadLibraryA( "kernel32.dll" );
+        if ( NULL == hKernel32 )
+                return FALSE;
+
+        void *pOrgEntry = GetProcAddress( hKernel32, "SetUnhandledExceptionFilter" );
+        if( NULL == pOrgEntry )
+                return FALSE;
+
+        unsigned char newJump[ 100 ];
+        DWORD dwOrgEntryAddr = (DWORD)pOrgEntry;
+        dwOrgEntryAddr += 5; // add 5 for 5 op-codes for jmp far
+        void *pNewFunc = &MyDummySetUnhandledExceptionFilter;
+        DWORD dwNewEntryAddr = (DWORD) pNewFunc;
+        DWORD dwRelativeAddr = dwNewEntryAddr - dwOrgEntryAddr;
+
+        newJump[ 0 ] = 0xE9;  // JMP absolute
+        memcpy( &newJump[ 1 ], &dwRelativeAddr, sizeof( pNewFunc ) );
+        SIZE_T bytesWritten;
+        BOOL bRet = WriteProcessMemory( GetCurrentProcess(), pOrgEntry, newJump, sizeof( pNewFunc ) + 1, &bytesWritten );
+        return bRet;
+#else
+        return FALSE;
+#endif
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//      Hook our exception handler and replace the system one
+void initExceptionHandler()
+{
+        LPTOP_LEVEL_EXCEPTION_FILTER prev_filter;
+
+        // save old exception handler in case we need to restore it at the end
+        prev_filter = SetUnhandledExceptionFilter( myWin32ExceptionHandler );
+        PreventSetUnhandledExceptionFilter();
+}
+
+bool checkExceptionHandler()
+{
+        bool ok = true;
+        LPTOP_LEVEL_EXCEPTION_FILTER prev_filter;
+        prev_filter = SetUnhandledExceptionFilter(myWin32ExceptionHandler);
+
+        PreventSetUnhandledExceptionFilter();
+
+        if (prev_filter != myWin32ExceptionHandler)
+        {
+                LL_WARNS("AppInit") << "Our exception handler (" << (void *)myWin32ExceptionHandler << ") replaced with " << prev_filter << "!" << LL_ENDL;
+                ok = false;
+        }
+
+        if (prev_filter == NULL)
+        {
+                ok = FALSE;
+                if (NULL == myWin32ExceptionHandler)
+                {
+                        LL_WARNS("AppInit") << "Exception handler uninitialized." << LL_ENDL;
+                }
+                else
+                {
+                        LL_WARNS("AppInit") << "Our exception handler (" << (void *)myWin32ExceptionHandler << ") replaced with NULL!" << LL_ENDL;
+                }
+        }
+
+        return ok;
+}
+#endif
+
+// If this application on Windows platform is a console application, a console is always
+// created which is bad. Making it a Windows "application" via CMake settings but not
+// adding any code to explicitly create windows does the right thing.
+#if LL_WINDOWS
+int APIENTRY WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow )
+#else
+int main(int argc, char **argv)
+#endif
+{
+        // Set up llerror logging
+        {
+                std::string path;
+                char impruPath[FILENAME_MAX];
+
+                if (!getImpruDir(impruPath, sizeof(impruPath)))
+                {
+                        path = "."; //FIXME: root directory of the system - bad idea
+                }
+                else
+                {
+                        path = std::string(impruPath);
+
+                        path.append(DIR_DELIMITER);
+                        path.append("app_settings");
+                }
+                LLError::initForApplication(path);
+//              LLError::setDefaultLevel(LLError::LEVEL_INFO);
+//              LLError::setPrintLocation(true);
+//              LLError::setTagLevel("Plugin", LLError::LEVEL_DEBUG);
+//              LLError::setTagLevel("PluginPipe", LLError::LEVEL_DEBUG);
+//              LLError::setTagLevel("PluginChild", LLError::LEVEL_DEBUG);
+//              LLError::setTagLevel("PluginInstance", LLError::LEVEL_DEBUG);
+
+//              LLError::logToFile("slplugin.log");
+        }
+
+#if LL_WINDOWS
+        if( strlen( lpCmdLine ) == 0 )
+        {
+                LL_ERRS("slplugin") << "usage: " << "SLPlugin" << " launcher_port" << LL_ENDL;
+        };
+
+        U32 port = 0;
+        if(!LLStringUtil::convertToU32(lpCmdLine, port))
+        {
+                LL_ERRS("slplugin") << "port number must be numeric" << LL_ENDL;
+        };
+
+        // Insert our exception handler into the system so this plugin doesn't
+        // display a crash message if something bad happens. The host app will
+        // see the missing heartbeat and log appropriately.
+        initExceptionHandler();
+#elif LL_DARWIN || LL_LINUX
+        if(argc < 2)
+        {
+                LL_ERRS("slplugin") << "usage: " << argv[0] << " launcher_port" << LL_ENDL;
+        }
+
+        U32 port = 0;
+        if(!LLStringUtil::convertToU32(argv[1], port))
+        {
+                LL_ERRS("slplugin") << "port number must be numeric" << LL_ENDL;
+        }
+
+        // Catch signals that most kinds of crashes will generate, and exit cleanly so the system crash dialog isn't shown.
+        signal(SIGILL, &crash_handler);         // illegal instruction
+# if LL_DARWIN
+        signal(SIGEMT, &crash_handler);         // emulate instruction executed
+# endif // LL_DARWIN
+        signal(SIGFPE, &crash_handler);         // floating-point exception
+        signal(SIGBUS, &crash_handler);         // bus error
+        signal(SIGSEGV, &crash_handler);        // segmentation violation
+        signal(SIGSYS, &crash_handler);         // non-existent system call invoked
+#endif
+
+#if LL_DARWIN
+        setupCocoa();
+        createAutoReleasePool();
+#endif
+
+        LLPluginProcessChild *plugin = new LLPluginProcessChild();
+
+        plugin->init(port);
+
+#if LL_DARWIN
+                deleteAutoReleasePool();
+#endif
+
+        LLTimer timer;
+        timer.start();
+
+#if LL_WINDOWS
+        checkExceptionHandler();
+#endif
+
+#if LL_DARWIN
+        // If the plugin opens a new window (such as the Flash plugin's fullscreen player), we may need to bring this plugin process to the foreground.
+        // Use this to track the current frontmost window and bring this process to the front if it changes.
+        WindowRef front_window = NULL;
+        WindowGroupRef layer_group = NULL;
+        int window_hack_state = 0;
+        CreateWindowGroup(kWindowGroupAttrFixedLevel, &layer_group);
+        if(layer_group)
+        {
+                // Start out with a window layer that's way out in front (fixes the problem with the menubar not getting hidden on first switch to fullscreen youtube)
+                SetWindowGroupName(layer_group, CFSTR("SLPlugin Layer"));
+                SetWindowGroupLevel(layer_group, kCGOverlayWindowLevel);                
+        }
+#endif
+
+#if LL_DARWIN
+        EventTargetRef event_target = GetEventDispatcherTarget();
+#endif
+        while(!plugin->isDone())
+        {
+#if LL_DARWIN
+                createAutoReleasePool();
+#endif
+                timer.reset();
+                plugin->idle();
+#if LL_DARWIN
+                {
+                        // Some plugins (webkit at least) will want an event loop.  This qualifies.
+                        EventRef event;
+                        if(ReceiveNextEvent(0, 0, kEventDurationNoWait, true, &event) == noErr)
+                        {
+                                SendEventToEventTarget (event, event_target);
+                                ReleaseEvent(event);
+                        }
+                        
+                        // Check for a change in this process's frontmost window.
+                        if(FrontWindow() != front_window)
+                        {
+                                ProcessSerialNumber self = { 0, kCurrentProcess };
+                                ProcessSerialNumber parent = { 0, kNoProcess };
+                                ProcessSerialNumber front = { 0, kNoProcess };
+                                Boolean this_is_front_process = false;
+                                Boolean parent_is_front_process = false;
+                                {
+                                        // Get this process's parent
+                                        ProcessInfoRec info;
+                                        info.processInfoLength = sizeof(ProcessInfoRec);
+                                        info.processName = NULL;
+                                        info.processAppSpec = NULL;
+                                        if(GetProcessInformation( &self, &info ) == noErr)
+                                        {
+                                                parent = info.processLauncher;
+                                        }
+                                        
+                                        // and figure out whether this process or its parent are currently frontmost
+                                        if(GetFrontProcess(&front) == noErr)
+                                        {
+                                                (void) SameProcess(&self, &front, &this_is_front_process);
+                                                (void) SameProcess(&parent, &front, &parent_is_front_process);
+                                        }
+                                }
+                                                                
+                                if((FrontWindow() != NULL) && (front_window == NULL))
+                                {
+                                        // Opening the first window
+                                        
+                                        if(window_hack_state == 0)
+                                        {
+                                                // Next time through the event loop, lower the window group layer
+                                                window_hack_state = 1;
+                                        }
+
+                                        if(layer_group)
+                                        {
+                                                SetWindowGroup(FrontWindow(), layer_group);
+                                        }
+                                        
+                                        if(parent_is_front_process)
+                                        {
+                                                // Bring this process's windows to the front.
+                                                (void) SetFrontProcess( &self );
+                                        }
+
+                                        ActivateWindow(FrontWindow(), true);                                    
+                                }
+                                else if((FrontWindow() == NULL) && (front_window != NULL))
+                                {
+                                        // Closing the last window
+                                        
+                                        if(this_is_front_process)
+                                        {
+                                                // Try to bring this process's parent to the front
+                                                (void) SetFrontProcess(&parent);
+                                        }
+                                }
+                                else if(window_hack_state == 1)
+                                {
+                                        if(layer_group)
+                                        {
+                                                // Set the window group level back to something less extreme
+                                                SetWindowGroupLevel(layer_group, kCGNormalWindowLevel);
+                                        }
+                                        window_hack_state = 2;
+                                }
+
+                                front_window = FrontWindow();
+
+                        }
+                }
+#endif
+                F64 elapsed = timer.getElapsedTimeF64();
+                F64 remaining = plugin->getSleepTime() - elapsed;
+
+                if(remaining <= 0.0f)
+                {
+                        // We've already used our full allotment.
+//                      LL_INFOS("slplugin") << "elapsed = " << elapsed * 1000.0f << " ms, remaining = " << remaining * 1000.0f << " ms, not sleeping" << LL_ENDL;
+
+                        // Still need to service the network...
+                        plugin->pump();
+                }
+                else
+                {
+
+//                      LL_INFOS("slplugin") << "elapsed = " << elapsed * 1000.0f << " ms, remaining = " << remaining * 1000.0f << " ms, sleeping for " << remaining * 1000.0f << " ms" << LL_ENDL;
+//                      timer.reset();
+
+                        // This also services the network as needed.
+                        plugin->sleep(remaining);
+
+//                      LL_INFOS("slplugin") << "slept for "<< timer.getElapsedTimeF64() * 1000.0f << " ms" <<  LL_ENDL;
+                }
+
+#if LL_WINDOWS
+        // More agressive checking of interfering exception handlers.
+        // Doesn't appear to be required so far - even for plugins
+        // that do crash with a single call to the intercept
+        // exception handler such as QuickTime.
+        //checkExceptionHandler();
+#endif
+
+#if LL_DARWIN
+                deleteAutoReleasePool();
+#endif
+        }
+
+        delete plugin;
+
+        return 0;
+}
+
diff --git a/linden/indra/llplugin/slplugin/slplugin_info.plist b/linden/indra/llplugin/slplugin/slplugin_info.plist
new file mode 100755
index 0000000..c459738
--- /dev/null
+++ b/linden/indra/llplugin/slplugin/slplugin_info.plist
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+        <key>CFBundleDevelopmentRegion</key>
+        <string>English</string>
+        <key>CFBundleInfoDictionaryVersion</key>
+        <string>6.0</string>
+        <key>LSUIElement</key>
+        <string>1</string>
+</dict>
+</plist>