27 files changed, 2420 insertions, 149 deletions

diff --git a/linden/indra/cmake/PulseAudio.cmake b/linden/indra/cmake/PulseAudio.cmake
new file mode 100644
index 0000000..f8087a8
--- /dev/null
+++ b/linden/indra/cmake/PulseAudio.cmake
@@ -0,0 +1,28 @@
+# -*- cmake -*-
+include(Prebuilt)
+
+if (STANDALONE)
+  include(FindPkgConfig)
+
+  pkg_check_modules(PULSEAUDIO REQUIRED libpulse-mainloop-glib)
+
+elseif (LINUX)
+  use_prebuilt_binary(pulseaudio)
+  set(PULSEAUDIO_FOUND ON FORCE BOOL)
+  set(PULSEAUDIO_INCLUDE_DIRS
+      ${LIBS_PREBUILT_DIR}/include
+      )
+  # We don't need to explicitly link against pulseaudio itself, because
+  # the viewer probes for the system's copy at runtime.
+  set(PULSEAUDIO_LIBRARIES
+    # none needed!
+    )
+endif (STANDALONE)
+
+if (PULSEAUDIO_FOUND)
+  set(PULSEAUDIO ON CACHE BOOL "Build with PulseAudio support, if available.")
+endif (PULSEAUDIO_FOUND)
+
+if (PULSEAUDIO)
+  add_definitions(-DLL_PULSEAUDIO_ENABLED=1)
+endif (PULSEAUDIO)
diff --git a/linden/indra/llplugin/CMakeLists.txt b/linden/indra/llplugin/CMakeLists.txt
index 8a2eff8..8eead94 100644
--- a/linden/indra/llplugin/CMakeLists.txt
+++ b/linden/indra/llplugin/CMakeLists.txt
@@ -7,6 +7,7 @@ if(HAVE_64_BIT)
 endif(HAVE_64_BIT)
 
 include(00-Common)
+include(CURL)
 include(LLCommon)
 include(LLImage)
 include(LLMath)
@@ -27,6 +28,7 @@ include_directories(
 
 set(llplugin_SOURCE_FILES
     llpluginclassmedia.cpp
+    llplugincookiestore.cpp
     llplugininstance.cpp
     llpluginmessage.cpp
     llpluginmessagepipe.cpp
@@ -40,6 +42,7 @@ set(llplugin_HEADER_FILES
 
     llpluginclassmedia.h
     llpluginclassmediaowner.h
+    llplugincookiestore.h
     llplugininstance.h
     llpluginmessage.h
     llpluginmessageclasses.h
@@ -65,3 +68,19 @@ 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}")
\ No newline at end of file
diff --git a/linden/indra/llplugin/llpluginclassmedia.cpp b/linden/indra/llplugin/llpluginclassmedia.cpp
index b958f0c..8664524 100755
--- a/linden/indra/llplugin/llpluginclassmedia.cpp
+++ b/linden/indra/llplugin/llpluginclassmedia.cpp
@@ -59,11 +59,15 @@ LLPluginClassMedia::LLPluginClassMedia(LLPluginClassMediaOwner *owner)
         mOwner = owner;
         mPlugin = NULL;
         reset();
+
+        //debug use
+        mDeleteOK = true ;
 }
 
 
 LLPluginClassMedia::~LLPluginClassMedia()
 {
+        llassert_always(mDeleteOK) ;
         reset();
 }
 
@@ -162,7 +166,7 @@ void LLPluginClassMedia::idle(void)
                 mPlugin->idle();
         }
         
-        if((mMediaWidth == -1) || (!mTextureParamsReceived) || (mPlugin == NULL))
+        if((mMediaWidth == -1) || (!mTextureParamsReceived) || (mPlugin == NULL) || (mPlugin->isBlocked()))
         {
                 // Can't process a size change at this time
         }
@@ -439,6 +443,12 @@ void LLPluginClassMedia::mouseEvent(EMouseEventType type, int button, int x, int
 {
         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.
@@ -995,6 +1005,13 @@ void LLPluginClassMedia::receivePluginMessage(const LLPluginMessage &message)
                         mClickTargetType = TARGET_NONE;
                         mediaEvent(LLPluginClassMediaOwner::MEDIA_EVENT_CLICK_LINK_NOFOLLOW);
                 }
+                else if(message_name == "cookie_set")
+                {
+                        if(mOwner)
+                        {
+                                mOwner->handleCookieSet(this, message.getValue("cookie"));
+                        }
+                }
                 else
                 {
                         LL_WARNS("Plugin") << "Unknown " << message_name << " class message: " << message_name << LL_ENDL;
@@ -1078,6 +1095,13 @@ void LLPluginClassMedia::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");
diff --git a/linden/indra/llplugin/llpluginclassmedia.h b/linden/indra/llplugin/llpluginclassmedia.h
index fc94563..abb7926 100755
--- a/linden/indra/llplugin/llpluginclassmedia.h
+++ b/linden/indra/llplugin/llpluginclassmedia.h
@@ -191,6 +191,7 @@ public:
         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();
@@ -374,6 +375,14 @@ protected:
         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
index c1f6ae1..9d1f352 100755
--- a/linden/indra/llplugin/llpluginclassmediaowner.h
+++ b/linden/indra/llplugin/llpluginclassmediaowner.h
@@ -41,6 +41,7 @@
 #include <queue>
 
 class LLPluginClassMedia;
+class LLPluginCookieStore;
 
 class LLPluginClassMediaOwner
 {
@@ -80,6 +81,7 @@ public:
         
         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..283ba35
--- /dev/null
+++ b/linden/indra/llplugin/llplugincookiestore.cpp
@@ -0,0 +1,671 @@
+/** 
+ * @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
+ */
+
+#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/llpluginmessagepipe.cpp b/linden/indra/llplugin/llpluginmessagepipe.cpp
index b16381c..8168b32 100755
--- a/linden/indra/llplugin/llpluginmessagepipe.cpp
+++ b/linden/indra/llplugin/llpluginmessagepipe.cpp
@@ -98,11 +98,14 @@ void LLPluginMessagePipeOwner::killMessagePipe(void)
         }
 }
 
-LLPluginMessagePipe::LLPluginMessagePipe(LLPluginMessagePipeOwner *owner, LLSocket::ptr_t socket)
+LLPluginMessagePipe::LLPluginMessagePipe(LLPluginMessagePipeOwner *owner, LLSocket::ptr_t socket):
+        mInputMutex(gAPRPoolp),
+        mOutputMutex(gAPRPoolp),
+        mOwner(owner),
+        mSocket(socket)
 {
-        mOwner = owner;
+        
         mOwner->setMessagePipe(this);
-        mSocket = socket;
 }
 
 LLPluginMessagePipe::~LLPluginMessagePipe()
@@ -116,6 +119,7 @@ LLPluginMessagePipe::~LLPluginMessagePipe()
 bool LLPluginMessagePipe::addMessage(const std::string &message)
 {
         // queue the message for later output
+        LLMutexLock lock(&mOutputMutex);
         mOutput += message;
         mOutput += MESSAGE_DELIMITER;   // message separator
         
@@ -151,6 +155,18 @@ void LLPluginMessagePipe::setSocketTimeout(apr_interval_time_t 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)
@@ -158,6 +174,7 @@ bool LLPluginMessagePipe::pump(F64 timeout)
                 apr_status_t status;
                 apr_size_t size;
                 
+                LLMutexLock lock(&mOutputMutex);
                 if(!mOutput.empty())
                 {
                         // write any outgoing messages
@@ -185,6 +202,17 @@ bool LLPluginMessagePipe::pump(F64 timeout)
                                 // 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
@@ -198,6 +226,19 @@ bool LLPluginMessagePipe::pump(F64 timeout)
                                 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.
@@ -218,8 +259,16 @@ bool LLPluginMessagePipe::pump(F64 timeout)
                         char input_buf[1024];
                         apr_size_t request_size;
                         
-                        // Start out by reading one byte, so that any data received will wake us up.
-                        request_size = 1;
+                        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));
@@ -238,11 +287,14 @@ bool LLPluginMessagePipe::pump(F64 timeout)
 //                              LL_INFOS("Plugin") << "after apr_socket_recv, size = " << size << LL_ENDL;
                                 
                                 if(size > 0)
+                                {
+                                        LLMutexLock lock(&mInputMutex);
                                         mInput.append(input_buf, size);
+                                }
 
                                 if(status == APR_SUCCESS)
                                 {
-//                                      llinfos << "success, read " << size << llendl;
+                                        LL_DEBUGS("PluginSocket") << "success, read " << size << LL_ENDL;
 
                                         if(size != request_size)
                                         {
@@ -252,16 +304,28 @@ bool LLPluginMessagePipe::pump(F64 timeout)
                                 }
                                 else if(APR_STATUS_IS_TIMEUP(status))
                                 {
-//                                      llinfos << "TIMEUP, read " << size << llendl;
+                                        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))
                                 {
-//                                      llinfos << "EAGAIN, read " << size << llendl;
+                                        LL_DEBUGS("PluginSocket") << "EAGAIN, read " << size << LL_ENDL;
 
-                                        // We've been doing partial reads, and we're done now.
+                                        // 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
@@ -278,22 +342,18 @@ bool LLPluginMessagePipe::pump(F64 timeout)
                                         break;
                                 }
 
-                                // Second and subsequent reads should not use the timeout
-                                setSocketTimeout(0);
-                                // and should try to fill the input buffer
-                                request_size = sizeof(input_buf);
+                                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();
                 }
         }
-
-        if(!result)
-        {
-                // If we got an error, we're done.
-                LL_INFOS("Plugin") << "Error from socket, cleaning up." << LL_ENDL;
-                delete this;
-        }
         
         return result;  
 }
@@ -301,26 +361,27 @@ bool LLPluginMessagePipe::pump(F64 timeout)
 void LLPluginMessagePipe::processInput(void)
 {
         // Look for input delimiter(s) in the input buffer.
-        int start = 0;
         int delim;
-        while((delim = mInput.find(MESSAGE_DELIMITER, start)) != std::string::npos)
+        mInputMutex.lock();
+        while((delim = mInput.find(MESSAGE_DELIMITER)) != std::string::npos)
         {       
                 // Let the owner process this message
                 if (mOwner)
                 {
-                        mOwner->receiveMessageRaw(mInput.substr(start, delim - start));
+                        // 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("Plugin") << "!mOwner" << LL_ENDL;
                 }
-                
-                start = delim + 1;
         }
-        
-        // Remove delivered messages from the input buffer.
-        if(start != 0)
-                mInput = mInput.substr(start);
-        
+        mInputMutex.unlock();
 }
 
diff --git a/linden/indra/llplugin/llpluginmessagepipe.h b/linden/indra/llplugin/llpluginmessagepipe.h
index 8f74f38..6eedca2 100755
--- a/linden/indra/llplugin/llpluginmessagepipe.h
+++ b/linden/indra/llplugin/llpluginmessagepipe.h
@@ -37,6 +37,7 @@
 #define LL_LLPLUGINMESSAGEPIPE_H
 
 #include "lliosocket.h"
+#include "llthread.h"
 
 class LLPluginMessagePipe;
 
@@ -53,7 +54,7 @@ public:
         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) ;
+        virtual void setMessagePipe(LLPluginMessagePipe *message_pipe);
 
 protected:
         // returns false if writeMessageRaw() would drop the message
@@ -78,14 +79,18 @@ public:
         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;
diff --git a/linden/indra/llplugin/llpluginprocesschild.cpp b/linden/indra/llplugin/llpluginprocesschild.cpp
index 0b7ce3d..8dbf2b3 100755
--- a/linden/indra/llplugin/llpluginprocesschild.cpp
+++ b/linden/indra/llplugin/llpluginprocesschild.cpp
@@ -50,6 +50,8 @@ LLPluginProcessChild::LLPluginProcessChild()
         mSocket = LLSocket::create(gAPRPoolp, LLSocket::STREAM_TCP);
         mSleepTime = PLUGIN_IDLE_SECONDS;       // default: send idle messages at 100Hz
         mCPUElapsed = 0.0f;
+        mBlockingRequest = false;
+        mBlockingResponseReceived = false;
 }
 
 LLPluginProcessChild::~LLPluginProcessChild()
@@ -85,9 +87,14 @@ void LLPluginProcessChild::idle(void)
         bool idle_again;
         do
         {
-                if(mSocketError != APR_SUCCESS)
+                if(APR_STATUS_IS_EOF(mSocketError))
                 {
-                        LL_INFOS("Plugin") << "message pipe is in error state, moving to STATE_ERROR"<< LL_ENDL;
+                        // Plugin socket was closed.  This covers both normal plugin termination and host crashes.
+                        setState(STATE_ERROR);
+                }
+                else if(mSocketError != APR_SUCCESS)
+                {
+                        LL_INFOS("Plugin") << "message pipe is in error state (" << mSocketError << "), moving to STATE_ERROR"<< LL_ENDL;
                         setState(STATE_ERROR);
                 }       
 
@@ -228,6 +235,7 @@ void LLPluginProcessChild::idle(void)
 
 void LLPluginProcessChild::sleep(F64 seconds)
 {
+        deliverQueuedMessages();
         if(mMessagePipe)
         {
                 mMessagePipe->pump(seconds);
@@ -240,6 +248,7 @@ void LLPluginProcessChild::sleep(F64 seconds)
 
 void LLPluginProcessChild::pump(void)
 {
+        deliverQueuedMessages();
         if(mMessagePipe)
         {
                 mMessagePipe->pump(0.0f);
@@ -311,15 +320,32 @@ void LLPluginProcessChild::receiveMessageRaw(const std::string &message)
 
         LL_DEBUGS("Plugin") << "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?
         
         {
-                // Decode this message
-                LLPluginMessage parsed;
-                parsed.parse(message);
-                
                 std::string message_class = parsed.getClass();
                 if(message_class == LLPLUGIN_MESSAGE_CLASS_INTERNAL)
                 {
@@ -427,7 +453,13 @@ void LLPluginProcessChild::receiveMessageRaw(const std::string &message)
 void LLPluginProcessChild::receivePluginMessage(const std::string &message)
 {
         LL_DEBUGS("Plugin") << "Received from plugin: " << message << LL_ENDL;
-
+        
+        if(mBlockingRequest)
+        {
+                // 
+                LL_ERRS("Plugin") << "Can't send a message while already waiting on a blocking request -- aborting!" << LL_ENDL;
+        }
+        
         // Incoming message from the plugin instance
         bool passMessage = true;
 
@@ -438,6 +470,12 @@ void LLPluginProcessChild::receivePluginMessage(const std::string &message)
                 // 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")
                 {
@@ -496,6 +534,19 @@ void LLPluginProcessChild::receivePluginMessage(const std::string &message)
                 LL_DEBUGS("Plugin") << "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;
+                }
+        }
 }
 
 
@@ -504,3 +555,15 @@ void LLPluginProcessChild::setState(EState state)
         LL_DEBUGS("Plugin") << "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
index 96ae7b4..5d643d7 100755
--- a/linden/indra/llplugin/llpluginprocesschild.h
+++ b/linden/indra/llplugin/llpluginprocesschild.h
@@ -36,6 +36,8 @@
 #ifndef LL_LLPLUGINPROCESSCHILD_H
 #define LL_LLPLUGINPROCESSCHILD_H
 
+#include <queue> //imprudence
+
 #include "llpluginmessage.h"
 #include "llpluginmessagepipe.h"
 #include "llplugininstance.h"
@@ -108,6 +110,11 @@ private:
         LLTimer mHeartbeat;
         F64             mSleepTime;
         F64             mCPUElapsed;
+        bool    mBlockingRequest;
+        bool    mBlockingResponseReceived;
+        std::queue<std::string> mMessageQueue;
+        
+        void deliverQueuedMessages();
         
 };
 
diff --git a/linden/indra/llplugin/llpluginprocessparent.cpp b/linden/indra/llplugin/llpluginprocessparent.cpp
index 8ea28f1..1bf34c5 100755
--- a/linden/indra/llplugin/llpluginprocessparent.cpp
+++ b/linden/indra/llplugin/llpluginprocessparent.cpp
@@ -47,8 +47,51 @@ LLPluginProcessParentOwner::~LLPluginProcessParentOwner()
         
 }
 
-LLPluginProcessParent::LLPluginProcessParent(LLPluginProcessParentOwner *owner)
+bool LLPluginProcessParent::sUseReadThread = false;
+apr_pollset_t *LLPluginProcessParent::sPollSet = NULL;
+bool LLPluginProcessParent::sPollsetNeedsRebuild = false;
+LLMutex *LLPluginProcessParent::sInstancesMutex;
+std::list<LLPluginProcessParent*> LLPluginProcessParent::sInstances;
+LLThread *LLPluginProcessParent::sReadThread = NULL;
+
+
+class LLPluginProcessParentPollThread: public LLThread
 {
+public:
+        LLPluginProcessParentPollThread() :
+                LLThread("LLPluginProcessParentPollThread", gAPRPoolp)
+        {
+        }
+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):
+        mIncomingQueueMutex(gAPRPoolp)
+{
+        if(!sInstancesMutex)
+        {
+                sInstancesMutex = new LLMutex(gAPRPoolp);
+        }
+        
         mOwner = owner;
         mBoundPort = 0;
         mState = STATE_UNINITIALIZED;
@@ -56,18 +99,38 @@ LLPluginProcessParent::LLPluginProcessParent(LLPluginProcessParentOwner *owner)
         mCPUUsage = 0.0;
         mDisableTimeout = false;
         mDebug = false;
+        mBlocked = false;
+        mPolledInput = false;
+        mPollFD.client_data = NULL;
 
         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("Plugin") << "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())
@@ -79,15 +142,17 @@ LLPluginProcessParent::~LLPluginProcessParent()
                 mSharedMemoryRegions.erase(iter);
         }
         
-        // orphaning the process means it won't be killed when the LLProcessLauncher is destructed.
-        // This is what we want -- it should exit cleanly once it notices the sockets have been closed.
-        mProcess.orphan();
+        mProcess.kill();
         killSockets();
 }
 
 void LLPluginProcessParent::killSockets(void)
 {
-        killMessagePipe();
+        {
+                LLMutexLock lock(&mIncomingQueueMutex);
+                killMessagePipe();
+        }
+
         mListenSocket.reset();
         mSocket.reset();
 }
@@ -161,21 +226,47 @@ void LLPluginProcessParent::idle(void)
 
         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)
                 {
-                        if(!mMessagePipe->pump())
+                        // Drain any queued outgoing messages
+                        mMessagePipe->pumpOutput();
+                        
+                        // Only do input processing here if this instance isn't in a pollset.
+                        if(!mPolledInput)
                         {
-//                              LL_WARNS("Plugin") << "Message pipe hit an error state" << LL_ENDL;
-                                errorState();
+                                mMessagePipe->pumpInput();
                         }
                 }
-
-                if((mSocketError != APR_SUCCESS) && (mState <= STATE_RUNNING))
+                
+                if(mState <= STATE_RUNNING)
                 {
-                        // The socket is in an error state -- the plugin is gone.
-                        LL_WARNS("Plugin") << "Socket hit an error state (" << mSocketError << ")" << LL_ENDL;
-                        errorState();
+                        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("Plugin") << "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().
@@ -356,7 +447,7 @@ void LLPluginProcessParent::idle(void)
                         break;
 
                         case STATE_HELLO:
-                                LL_DEBUGS("Plugin") << "received hello message" << llendl;
+                                LL_DEBUGS("Plugin") << "received hello message" << LL_ENDL;
                                 
                                 // Send the message to load the plugin
                                 {
@@ -390,7 +481,7 @@ void LLPluginProcessParent::idle(void)
                                 }
                                 else if(pluginLockedUp())
                                 {
-                                        LL_WARNS("Plugin") << "timeout in exiting state, bailing out" << llendl;
+                                        LL_WARNS("Plugin") << "timeout in exiting state, bailing out" << LL_ENDL;
                                         errorState();
                                 }
                         break;
@@ -412,8 +503,7 @@ void LLPluginProcessParent::idle(void)
                         break;
                         
                         case STATE_CLEANUP:
-                                // Don't do a kill here anymore -- closing the sockets is the new 'kill'.
-                                mProcess.orphan();
+                                mProcess.kill();
                                 killSockets();
                                 setState(STATE_DONE);
                         break;
@@ -481,23 +571,323 @@ void LLPluginProcessParent::setSleepTime(F64 sleep_time, bool force_send)
 
 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("Plugin") << "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 = gAPRPoolp;
+                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;
+        }
+        
+        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.
+                        apr_status_t status = apr_pollset_create(&sPollSet, count, gAPRPoolp, 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;
+#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("Plugin") << "Received: " << message << LL_ENDL;
-
-        // FIXME: should this go into a queue instead?
         
         LLPluginMessage parsed;
         if(parsed.parse(message) != -1)
         {
-                receiveMessage(parsed);
+                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);
         }
 }
 
@@ -691,18 +1081,15 @@ bool LLPluginProcessParent::pluginLockedUpOrQuit()
 {
         bool result = false;
         
-        if(!mDisableTimeout && !mDebug)
+        if(!mProcess.isRunning())
         {
-                if(!mProcess.isRunning())
-                {
-                        LL_WARNS("Plugin") << "child exited" << llendl;
-                        result = true;
-                }
-                else if(pluginLockedUp())
-                {
-                        LL_WARNS("Plugin") << "timeout" << llendl;
-                        result = true;
-                }
+                LL_WARNS("Plugin") << "child exited" << LL_ENDL;
+                result = true;
+        }
+        else if(pluginLockedUp())
+        {
+                LL_WARNS("Plugin") << "timeout" << LL_ENDL;
+                result = true;
         }
         
         return result;
@@ -710,6 +1097,12 @@ bool LLPluginProcessParent::pluginLockedUpOrQuit()
 
 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());
 }
diff --git a/linden/indra/llplugin/llpluginprocessparent.h b/linden/indra/llplugin/llpluginprocessparent.h
index 523ce51..a8929b1 100755
--- a/linden/indra/llplugin/llpluginprocessparent.h
+++ b/linden/indra/llplugin/llpluginprocessparent.h
@@ -36,6 +36,8 @@
 #ifndef LL_LLPLUGINPROCESSPARENT_H
 #define LL_LLPLUGINPROCESSPARENT_H
 
+#include <queue> //imprudence
+
 #include "llapr.h"
 #include "llprocesslauncher.h"
 #include "llpluginmessage.h"
@@ -43,12 +45,14 @@
 #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() {};
@@ -76,6 +80,9 @@ public:
         // 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
@@ -89,7 +96,9 @@ public:
         void receiveMessage(const LLPluginMessage &message);
         
         // Inherited from LLPluginMessagePipeOwner
-        void receiveMessageRaw(const std::string &message);
+        /*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.
@@ -112,7 +121,11 @@ public:
         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
@@ -162,12 +175,27 @@ private:
         
         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;
+        static apr_pollset_t *sPollSet;
+        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/slplugin/CMakeLists.txt b/linden/indra/llplugin/slplugin/CMakeLists.txt
index 4a7d670..81d9299 100755
--- a/linden/indra/llplugin/slplugin/CMakeLists.txt
+++ b/linden/indra/llplugin/slplugin/CMakeLists.txt
@@ -16,6 +16,7 @@ include_directories(
 if (DARWIN)
     include(CMakeFindFrameworks)
     find_library(CARBON_LIBRARY Carbon)
+    find_library(COCOA_LIBRARY Cocoa)
 endif (DARWIN)
 
 
@@ -25,11 +26,33 @@ 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}
@@ -44,12 +67,16 @@ add_dependencies(SLPlugin
 )
 
 if (DARWIN)
-  # Mac version needs to link against carbon, and also needs an embedded plist (to set LSBackgroundOnly)
-  target_link_libraries(SLPlugin ${CARBON_LIBRARY})
-  set_target_properties(
-    SLPlugin
-    PROPERTIES
-    LINK_FLAGS "-Wl,-sectcreate,__TEXT,__info_plist,${CMAKE_CURRENT_SOURCE_DIR}/slplugin_info.plist"
+  # 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
index 649d568..64c087b 100755
--- a/linden/indra/llplugin/slplugin/slplugin.cpp
+++ b/linden/indra/llplugin/slplugin/slplugin.cpp
@@ -46,6 +46,7 @@
 
 #if LL_DARWIN
         #include <Carbon/Carbon.h>
+        #include "slplugin-objc.h"
 #endif
 
 #if LL_DARWIN || LL_LINUX
@@ -53,7 +54,7 @@
 #endif
 
 /*
-        On Mac OS, since we call WaitNextEvent, this process will show up in the dock unless we set the LSBackgroundOnly flag in the Info.plist.
+        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:
 
@@ -62,7 +63,8 @@
         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
@@ -230,10 +232,19 @@ int main(int argc, char **argv)
         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();
 
@@ -242,10 +253,28 @@ int main(int argc, char **argv)
 #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
@@ -257,6 +286,80 @@ int main(int argc, char **argv)
                                 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();
@@ -289,6 +392,10 @@ int main(int argc, char **argv)
         // exception handler such as QuickTime.
         //checkExceptionHandler();
 #endif
+
+#if LL_DARWIN
+                deleteAutoReleasePool();
+#endif
         }
 
         delete plugin;
diff --git a/linden/indra/llplugin/slplugin/slplugin_info.plist b/linden/indra/llplugin/slplugin/slplugin_info.plist
index b1daf87..c459738 100755
--- a/linden/indra/llplugin/slplugin/slplugin_info.plist
+++ b/linden/indra/llplugin/slplugin/slplugin_info.plist
@@ -6,7 +6,7 @@
         <string>English</string>
         <key>CFBundleInfoDictionaryVersion</key>
         <string>6.0</string>
-        <key>LSBackgroundOnly</key>
-        <true/>
+        <key>LSUIElement</key>
+        <string>1</string>
 </dict>
 </plist>
diff --git a/linden/indra/media_plugins/webkit/CMakeLists.txt b/linden/indra/media_plugins/webkit/CMakeLists.txt
index a47d5e0..2ab4a95 100644
--- a/linden/indra/media_plugins/webkit/CMakeLists.txt
+++ b/linden/indra/media_plugins/webkit/CMakeLists.txt
@@ -18,7 +18,7 @@ include(Linking)
 include(PluginAPI)
 include(MediaPluginBase)
 include(FindOpenGL)
-#include(PulseAudio)
+include(PulseAudio)
 
 include(WebKitLibPlugin)
 
@@ -48,6 +48,9 @@ if(NOT CMAKE_SIZEOF_VOID_P MATCHES 4)
                 add_definitions(-fPIC)
         endif(WINDOWS)
 endif (NOT CMAKE_SIZEOF_VOID_P MATCHES 4)
+set(media_plugin_webkit_HEADER_FILES
+    volume_catcher.h
+    )
 
 set(media_plugin_webkit_LINK_LIBRARIES
   ${LLPLUGIN_LIBRARIES}
@@ -58,13 +61,33 @@ set(media_plugin_webkit_LINK_LIBRARIES
   ${PULSEAUDIO_LIBRARIES}
 )
 
+# Select which VolumeCatcher implementation to use
 if (LINUX)
-  list(APPEND media_plugin_webkit_SOURCE_FILES linux_volume_catcher.cpp)
+  if (PULSEAUDIO)
+    list(APPEND media_plugin_webkit_SOURCE_FILES linux_volume_catcher.cpp)
+  endif (PULSEAUDIO)
   list(APPEND media_plugin_webkit_LINK_LIBRARIES
-    ${UI_LIBRARIES}  # for glib/GTK
-    )
-endif(LINUX)
-
+       ${UI_LIBRARIES}     # for glib/GTK
+       )
+elseif (DARWIN)
+  list(APPEND media_plugin_webkit_SOURCE_FILES mac_volume_catcher.cpp)
+  find_library(CORESERVICES_LIBRARY CoreServices)
+  find_library(AUDIOUNIT_LIBRARY AudioUnit)
+  list(APPEND media_plugin_webkit_LINK_LIBRARIES
+       ${CORESERVICES_LIBRARY}     # for Component Manager calls
+       ${AUDIOUNIT_LIBRARY}        # for AudioUnit calls
+       )
+elseif (WINDOWS)
+  list(APPEND media_plugin_webkit_SOURCE_FILES windows_volume_catcher.cpp)
+else (LINUX)
+  # All other platforms use the dummy volume catcher for now.
+  list(APPEND media_plugin_webkit_SOURCE_FILES dummy_volume_catcher.cpp)
+endif (LINUX)
+
+set_source_files_properties(${media_plugin_webkit_HEADER_FILES}
+                            PROPERTIES HEADER_FILE_ONLY TRUE)
+
+list(APPEND media_plugin_webkit_SOURCE_FILES ${media_plugin_webkit_HEADER_FILES})
 
 add_library(media_plugin_webkit
     SHARED
diff --git a/linden/indra/media_plugins/webkit/dummy_volume_catcher.cpp b/linden/indra/media_plugins/webkit/dummy_volume_catcher.cpp
new file mode 100644
index 0000000..4df9887
--- /dev/null
+++ b/linden/indra/media_plugins/webkit/dummy_volume_catcher.cpp
@@ -0,0 +1,65 @@
+/** 
+ * @file dummy_volume_catcher.cpp
+ * @brief A null implementation of the "VolumeCatcher" class for platforms where it's not implemented yet.
+ *
+ * @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 "volume_catcher.h"
+
+
+class VolumeCatcherImpl
+{
+};
+
+/////////////////////////////////////////////////////
+
+VolumeCatcher::VolumeCatcher()
+{
+        pimpl = NULL;
+}
+
+VolumeCatcher::~VolumeCatcher()
+{
+}
+
+void VolumeCatcher::setVolume(F32 volume)
+{
+}
+
+void VolumeCatcher::setPan(F32 pan)
+{
+}
+
+void VolumeCatcher::pump()
+{
+}
+
diff --git a/linden/indra/media_plugins/webkit/linux_volume_catcher.cpp b/linden/indra/media_plugins/webkit/linux_volume_catcher.cpp
index 15a2dfb..c4c4181 100755..100644
--- a/linden/indra/media_plugins/webkit/linux_volume_catcher.cpp
+++ b/linden/indra/media_plugins/webkit/linux_volume_catcher.cpp
@@ -42,15 +42,16 @@
   5) Keep a list of all living audio players that we care about, adjust the volumes of all of them when we get a new setVolume() call
  */
 
-#include "linden_common.h"
+# include <set> //imprudence
 
-#include "linux_volume_catcher.h"
+#include "linden_common.h"
 
+#include "volume_catcher.h"
 
-#if LL_PULSEAUDIO_ENABLED
 
 extern "C" {
 #include <glib.h>
+#include <glib-object.h>
 
 #include <pulse/introspect.h>
 #include <pulse/context.h>
@@ -163,11 +164,11 @@ extern "C" {
 }
 
 
-class LinuxVolumeCatcherImpl
+class VolumeCatcherImpl
 {
 public:
-        LinuxVolumeCatcherImpl();
-        ~LinuxVolumeCatcherImpl();
+        VolumeCatcherImpl();
+        ~VolumeCatcherImpl();
 
         void setVolume(F32 volume);
         void pump(void);
@@ -191,7 +192,7 @@ public:
         bool mGotSyms;
 };
 
-LinuxVolumeCatcherImpl::LinuxVolumeCatcherImpl()
+VolumeCatcherImpl::VolumeCatcherImpl()
         : mDesiredVolume(0.0f),
           mMainloop(NULL),
           mPAContext(NULL),
@@ -201,17 +202,17 @@ LinuxVolumeCatcherImpl::LinuxVolumeCatcherImpl()
         init();
 }
 
-LinuxVolumeCatcherImpl::~LinuxVolumeCatcherImpl()
+VolumeCatcherImpl::~VolumeCatcherImpl()
 {
         cleanup();
 }
 
-bool LinuxVolumeCatcherImpl::loadsyms(std::string pulse_dso_name)
+bool VolumeCatcherImpl::loadsyms(std::string pulse_dso_name)
 {
         return grab_pa_syms(pulse_dso_name);
 }
 
-void LinuxVolumeCatcherImpl::init()
+void VolumeCatcherImpl::init()
 {
         // try to be as defensive as possible because PA's interface is a
         // bit fragile and (for our purposes) we'd rather simply not function
@@ -224,6 +225,10 @@ void LinuxVolumeCatcherImpl::init()
         mGotSyms = loadsyms("libpulse-mainloop-glib.so.0");
         if (!mGotSyms) return;
 
+        // better make double-sure glib itself is initialized properly.
+        if (!g_thread_supported ()) g_thread_init (NULL);
+        g_type_init();
+
         mMainloop = llpa_glib_mainloop_new(g_main_context_default());
         if (mMainloop)
         {
@@ -264,7 +269,7 @@ void LinuxVolumeCatcherImpl::init()
         }
 }
 
-void LinuxVolumeCatcherImpl::cleanup()
+void VolumeCatcherImpl::cleanup()
 {
         mConnected = false;
 
@@ -282,7 +287,7 @@ void LinuxVolumeCatcherImpl::cleanup()
         mMainloop = NULL;
 }
 
-void LinuxVolumeCatcherImpl::setVolume(F32 volume)
+void VolumeCatcherImpl::setVolume(F32 volume)
 {
         mDesiredVolume = volume;
         
@@ -296,13 +301,13 @@ void LinuxVolumeCatcherImpl::setVolume(F32 volume)
         pump();
 }
 
-void LinuxVolumeCatcherImpl::pump()
+void VolumeCatcherImpl::pump()
 {
         gboolean may_block = FALSE;
         g_main_context_iteration(g_main_context_default(), may_block);
 }
 
-void LinuxVolumeCatcherImpl::connected_okay()
+void VolumeCatcherImpl::connected_okay()
 {
         pa_operation *op;
 
@@ -326,7 +331,7 @@ void LinuxVolumeCatcherImpl::connected_okay()
         }
 }
 
-void LinuxVolumeCatcherImpl::update_all_volumes(F32 volume)
+void VolumeCatcherImpl::update_all_volumes(F32 volume)
 {
         for (std::set<U32>::iterator it = mSinkInputIndices.begin();
              it != mSinkInputIndices.end(); ++it)
@@ -335,7 +340,7 @@ void LinuxVolumeCatcherImpl::update_all_volumes(F32 volume)
         }
 }
 
-void LinuxVolumeCatcherImpl::update_index_volume(U32 index, F32 volume)
+void VolumeCatcherImpl::update_index_volume(U32 index, F32 volume)
 {
         static pa_cvolume cvol;
         llpa_cvolume_set(&cvol, mSinkInputNumChannels[index],
@@ -357,7 +362,7 @@ void LinuxVolumeCatcherImpl::update_index_volume(U32 index, F32 volume)
 
 void callback_discovered_sinkinput(pa_context *context, const pa_sink_input_info *sii, int eol, void *userdata)
 {
-        LinuxVolumeCatcherImpl *impl = dynamic_cast<LinuxVolumeCatcherImpl*>((LinuxVolumeCatcherImpl*)userdata);
+        VolumeCatcherImpl *impl = dynamic_cast<VolumeCatcherImpl*>((VolumeCatcherImpl*)userdata);
         llassert(impl);
 
         if (0 == eol)
@@ -388,7 +393,7 @@ void callback_discovered_sinkinput(pa_context *context, const pa_sink_input_info
 
 void callback_subscription_alert(pa_context *context, pa_subscription_event_type_t t, uint32_t index, void *userdata)
 {
-        LinuxVolumeCatcherImpl *impl = dynamic_cast<LinuxVolumeCatcherImpl*>((LinuxVolumeCatcherImpl*)userdata);
+        VolumeCatcherImpl *impl = dynamic_cast<VolumeCatcherImpl*>((VolumeCatcherImpl*)userdata);
         llassert(impl);
 
         switch (t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) {
@@ -422,7 +427,7 @@ void callback_subscription_alert(pa_context *context, pa_subscription_event_type
 
 void callback_context_state(pa_context *context, void *userdata)
 {
-        LinuxVolumeCatcherImpl *impl = dynamic_cast<LinuxVolumeCatcherImpl*>((LinuxVolumeCatcherImpl*)userdata);
+        VolumeCatcherImpl *impl = dynamic_cast<VolumeCatcherImpl*>((VolumeCatcherImpl*)userdata);
         llassert(impl);
         
         switch (llpa_context_get_state(context))
@@ -443,48 +448,30 @@ void callback_context_state(pa_context *context, void *userdata)
 
 /////////////////////////////////////////////////////
 
-LinuxVolumeCatcher::LinuxVolumeCatcher()
+VolumeCatcher::VolumeCatcher()
 {
-        pimpl = new LinuxVolumeCatcherImpl();
+        pimpl = new VolumeCatcherImpl();
 }
 
-LinuxVolumeCatcher::~LinuxVolumeCatcher()
+VolumeCatcher::~VolumeCatcher()
 {
         delete pimpl;
         pimpl = NULL;
 }
 
-void LinuxVolumeCatcher::setVolume(F32 volume)
+void VolumeCatcher::setVolume(F32 volume)
 {
         llassert(pimpl);
         pimpl->setVolume(volume);
 }
 
-void LinuxVolumeCatcher::pump()
-{
-        llassert(pimpl);
-        pimpl->pump();
-}
-
-#else // !LL_PULSEAUDIO_ENABLED
-
-// stub.
-
-LinuxVolumeCatcher::LinuxVolumeCatcher()
-{
-        pimpl = NULL;
-}
-
-LinuxVolumeCatcher::~LinuxVolumeCatcher()
-{
-}
-
-void LinuxVolumeCatcher::setVolume(F32 volume)
+void VolumeCatcher::setPan(F32 pan)
 {
+        // TODO: implement this (if possible)
 }
 
-void LinuxVolumeCatcher::pump()
+void VolumeCatcher::pump()
 {
+        llassert(pimpl);
+        pimpl->pump();
 }
-
-#endif // LL_PULSEAUDIO_ENABLED
diff --git a/linden/indra/media_plugins/webkit/linux_volume_catcher_pa_syms.inc b/linden/indra/media_plugins/webkit/linux_volume_catcher_pa_syms.inc
index d806b48..d806b48 100755..100644
--- a/linden/indra/media_plugins/webkit/linux_volume_catcher_pa_syms.inc
+++ b/linden/indra/media_plugins/webkit/linux_volume_catcher_pa_syms.inc
diff --git a/linden/indra/media_plugins/webkit/linux_volume_catcher_paglib_syms.inc b/linden/indra/media_plugins/webkit/linux_volume_catcher_paglib_syms.inc
index abf628c..abf628c 100755..100644
--- a/linden/indra/media_plugins/webkit/linux_volume_catcher_paglib_syms.inc
+++ b/linden/indra/media_plugins/webkit/linux_volume_catcher_paglib_syms.inc
diff --git a/linden/indra/media_plugins/webkit/mac_volume_catcher.cpp b/linden/indra/media_plugins/webkit/mac_volume_catcher.cpp
new file mode 100644
index 0000000..190823f
--- /dev/null
+++ b/linden/indra/media_plugins/webkit/mac_volume_catcher.cpp
@@ -0,0 +1,275 @@
+/** 
+ * @file mac_volume_catcher.cpp
+ * @brief A Mac OS X specific hack to control the volume level of all audio channels opened by a process.
+ *
+ * @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
+ */
+
+/**************************************************************************************************************
+        This code works by using CaptureComponent to capture the "Default Output" audio component
+        (kAudioUnitType_Output/kAudioUnitSubType_DefaultOutput) and delegating all calls to the original component.
+        It does this just to keep track of all instances of the default output component, so that it can set the
+        kHALOutputParam_Volume parameter on all of them to adjust the output volume.
+**************************************************************************************************************/
+
+#include "volume_catcher.h"
+
+#include <Carbon/Carbon.h>
+#include <QuickTime/QuickTime.h>
+#include <AudioUnit/AudioUnit.h>
+
+struct VolumeCatcherStorage;
+
+class VolumeCatcherImpl
+{
+public:
+
+        void setVolume(F32 volume);
+        void setPan(F32 pan);
+        
+        void setInstanceVolume(VolumeCatcherStorage *instance);
+        
+        std::list<VolumeCatcherStorage*> mComponentInstances;
+        Component mOriginalDefaultOutput;
+        Component mVolumeAdjuster;
+        
+        static VolumeCatcherImpl *getInstance();
+private:
+        // This is a singleton class -- both callers and the component implementation should use getInstance() to find the instance.
+        VolumeCatcherImpl();
+        static VolumeCatcherImpl *sInstance;
+        
+        // The singlar instance of this class is expected to last until the process exits.
+        // To ensure this, we declare the destructor here but never define it, so any code which attempts to destroy the instance will not link.
+        ~VolumeCatcherImpl();   
+        
+        F32 mVolume;
+        F32 mPan;
+};
+
+VolumeCatcherImpl *VolumeCatcherImpl::sInstance = NULL;;
+
+struct VolumeCatcherStorage
+{
+        ComponentInstance self;
+        ComponentInstance delegate;
+};
+
+static ComponentResult volume_catcher_component_entry(ComponentParameters *cp, Handle componentStorage);
+static ComponentResult volume_catcher_component_open(VolumeCatcherStorage *storage, ComponentInstance self);
+static ComponentResult volume_catcher_component_close(VolumeCatcherStorage *storage, ComponentInstance self);
+
+VolumeCatcherImpl *VolumeCatcherImpl::getInstance()
+{
+        if(!sInstance)
+        {
+                sInstance = new VolumeCatcherImpl;
+        }
+        
+        return sInstance;
+}
+
+VolumeCatcherImpl::VolumeCatcherImpl()
+{
+        mVolume = 1.0;  // default to full volume
+        mPan = 0.0;             // and center pan
+                
+        ComponentDescription desc;
+        desc.componentType = kAudioUnitType_Output;
+        desc.componentSubType = kAudioUnitSubType_DefaultOutput;
+        desc.componentManufacturer = kAudioUnitManufacturer_Apple;
+        desc.componentFlags = 0;
+        desc.componentFlagsMask = 0;
+        
+        // Find the original default output component
+        mOriginalDefaultOutput = FindNextComponent(NULL, &desc);
+
+        // Register our own output component with the same parameters
+        mVolumeAdjuster = RegisterComponent(&desc, NewComponentRoutineUPP(volume_catcher_component_entry), 0, NULL, NULL, NULL);
+
+        // Capture the original component, so we always get found instead.
+        CaptureComponent(mOriginalDefaultOutput, mVolumeAdjuster);
+
+}
+
+static ComponentResult volume_catcher_component_entry(ComponentParameters *cp, Handle componentStorage)
+{
+        ComponentResult result = badComponentSelector;
+        VolumeCatcherStorage *storage = (VolumeCatcherStorage*)componentStorage;
+        
+        switch(cp->what)
+        {
+                case kComponentOpenSelect:
+//                      std::cerr << "kComponentOpenSelect" << std::endl;
+                        result = CallComponentFunctionWithStorageProcInfo((Handle)storage, cp, (ProcPtr)volume_catcher_component_open, uppCallComponentOpenProcInfo);
+                break;
+
+                case kComponentCloseSelect:
+//                      std::cerr << "kComponentCloseSelect" << std::endl;
+                        result = CallComponentFunctionWithStorageProcInfo((Handle)storage, cp, (ProcPtr)volume_catcher_component_close, uppCallComponentCloseProcInfo);
+                        // CallComponentFunctionWithStorageProcInfo
+                break;
+                
+                default:
+//                      std::cerr << "Delegating selector: " << cp->what << " to component instance " << storage->delegate << std::endl;
+                        result = DelegateComponentCall(cp, storage->delegate);
+                break;
+        }
+        
+        return result;
+}
+
+static ComponentResult volume_catcher_component_open(VolumeCatcherStorage *storage, ComponentInstance self)
+{
+        ComponentResult result = noErr;
+        VolumeCatcherImpl *impl = VolumeCatcherImpl::getInstance();     
+        
+        storage = new VolumeCatcherStorage;
+
+        storage->self = self;
+        storage->delegate = NULL;
+
+        result = OpenAComponent(impl->mOriginalDefaultOutput, &(storage->delegate));
+        
+        if(result != noErr)
+        {
+//              std::cerr << "OpenAComponent result = " << result << ", component ref = " << storage->delegate << std::endl;
+                
+                // If we failed to open the delagate component, our open is going to fail.  Clean things up.
+                delete storage;
+        }
+        else
+        {
+                // Success -- set up this component's storage
+                SetComponentInstanceStorage(self, (Handle)storage);
+
+                // add this instance to the global list
+                impl->mComponentInstances.push_back(storage);   
+                
+                // and set up the initial volume
+                impl->setInstanceVolume(storage);
+        }
+
+        return result;
+}
+
+static ComponentResult volume_catcher_component_close(VolumeCatcherStorage *storage, ComponentInstance self)
+{
+        ComponentResult result = noErr;
+        
+        if(storage)
+        {
+                if(storage->delegate)
+                {
+                        CloseComponent(storage->delegate);
+                        storage->delegate = NULL;
+                }
+                
+                VolumeCatcherImpl *impl = VolumeCatcherImpl::getInstance();     
+                impl->mComponentInstances.remove(storage);
+                delete[] storage;
+        }
+                
+        return result;
+}
+
+void VolumeCatcherImpl::setVolume(F32 volume)
+{
+        VolumeCatcherImpl *impl = VolumeCatcherImpl::getInstance();     
+        impl->mVolume = volume;
+        
+        // Iterate through all known instances, setting the volume on each.
+        for(std::list<VolumeCatcherStorage*>::iterator iter = mComponentInstances.begin(); iter != mComponentInstances.end(); ++iter)
+        {
+                impl->setInstanceVolume(*iter);
+        }
+}
+
+void VolumeCatcherImpl::setPan(F32 pan)
+{
+        VolumeCatcherImpl *impl = VolumeCatcherImpl::getInstance();     
+        impl->mPan = pan;
+        
+        // TODO: implement this.
+        // This will probably require adding a "panner" audio unit to the chain somehow.
+        // There's also a "3d mixer" component that we might be able to use...
+}
+
+void VolumeCatcherImpl::setInstanceVolume(VolumeCatcherStorage *instance)
+{
+//      std::cerr << "Setting volume on component instance: " << (instance->delegate) << " to " << mVolume << std::endl;
+        
+        OSStatus err = noErr;
+        
+        if(instance && instance->delegate)
+        {
+                err = AudioUnitSetParameter(
+                                instance->delegate, 
+                                kHALOutputParam_Volume, 
+                                kAudioUnitScope_Global,
+                                0, 
+                                mVolume, 
+                                0);
+        }
+        
+        if(err)
+        {
+//              std::cerr << "    AudioUnitSetParameter returned " << err << std::endl;
+        }
+}
+
+/////////////////////////////////////////////////////
+
+VolumeCatcher::VolumeCatcher()
+{
+        pimpl = VolumeCatcherImpl::getInstance();
+}
+
+VolumeCatcher::~VolumeCatcher()
+{
+        // Let the instance persist until exit.
+}
+
+void VolumeCatcher::setVolume(F32 volume)
+{
+        pimpl->setVolume(volume);
+}
+
+void VolumeCatcher::setPan(F32 pan)
+{
+        pimpl->setPan(pan);
+}
+
+void VolumeCatcher::pump()
+{
+        // No periodic tasks are necessary for this implementation.
+}
+
diff --git a/linden/indra/media_plugins/webkit/media_plugin_webkit.cpp b/linden/indra/media_plugins/webkit/media_plugin_webkit.cpp
index 09ba8dc..f9b6451 100755
--- a/linden/indra/media_plugins/webkit/media_plugin_webkit.cpp
+++ b/linden/indra/media_plugins/webkit/media_plugin_webkit.cpp
@@ -49,13 +49,15 @@
 #if LL_LINUX
 # include <iomanip> 
 # define LL_QTWEBKIT_USES_PIXMAPS 0
+extern "C" {
+# include <glib.h>
+# include <glib-object.h>
+}
 #else
 # define LL_QTWEBKIT_USES_PIXMAPS 0
 #endif // LL_LINUX
 
-#if LL_LINUX
-# include "linux_volume_catcher.h"
-#endif // LL_LINUX
+# include "volume_catcher.h"
 
 #if LL_WINDOWS
 # include <direct.h>
@@ -65,7 +67,7 @@
 #endif
 
 #if LL_WINDOWS
-        // *NOTE:Mani - This captures the module handle fo rthe dll. This is used below
+        // *NOTE:Mani - This captures the module handle for the dll. This is used below
         // to get the path to this dll for webkit initialization.
         // I don't know how/if this can be done with apr...
         namespace {     HMODULE gModuleHandle;};
@@ -122,9 +124,7 @@ private:
         F32 mBackgroundG;
         F32 mBackgroundB;
         
-#if LL_LINUX
-        LinuxVolumeCatcher mLinuxVolumeCatcher;
-#endif // LL_LINUX
+        VolumeCatcher mVolumeCatcher;
 
         void setInitState(int state)
         {
@@ -136,11 +136,19 @@ private:
         //
         void update(int milliseconds)
         {
+#if LL_QTLINUX_DOESNT_HAVE_GLIB
+                // pump glib generously, as Linux browser plugins are on the
+                // glib main loop, even if the browser itself isn't - ugh
+                // This is NOT NEEDED if Qt itself was built with glib
+                // mainloop integration.
+                GMainContext *mainc = g_main_context_default();
+                while(g_main_context_iteration(mainc, FALSE));
+#endif // LL_QTLINUX_DOESNT_HAVE_GLIB
+
+                // pump qt
                 LLQtWebKit::getInstance()->pump( milliseconds );
                 
-#if LL_LINUX
-                mLinuxVolumeCatcher.pump();
-#endif // LL_LINUX
+                mVolumeCatcher.pump();
 
                 checkEditState();
                 
@@ -209,6 +217,14 @@ private:
                 }
                 std::string application_dir = std::string( cwd );
 
+#if LL_LINUX
+                // take care to initialize glib properly, because some
+                // versions of Qt don't, and we indirectly need it for (some
+                // versions of) Flash to not crash the browser.
+                if (!g_thread_supported ()) g_thread_init (NULL);
+                g_type_init();
+#endif
+
 #if LL_DARWIN
                 // When running under the Xcode debugger, there's a setting called "Break on Debugger()/DebugStr()" which defaults to being turned on.
                 // This causes the environment variable USERBREAK to be set to 1, which causes these legacy calls to break into the debugger.
@@ -306,11 +322,14 @@ private:
                 // append details to agent string
                 LLQtWebKit::getInstance()->setBrowserAgentId( mUserAgent );
 
+                // Set up window open behavior
+                LLQtWebKit::getInstance()->setWindowOpenBehavior(mBrowserWindowId, LLQtWebKit::WOB_SIMULATE_BLANK_HREF_CLICK);
+                
 #if !LL_QTWEBKIT_USES_PIXMAPS
                 // don't flip bitmap
                 LLQtWebKit::getInstance()->flipWindow( mBrowserWindowId, true );
 #endif // !LL_QTWEBKIT_USES_PIXMAPS
-                
+
                 // set background color
                 // convert background color channels from [0.0, 1.0] to [0, 255];
                 LLQtWebKit::getInstance()->setBackgroundColor( mBrowserWindowId, int(mBackgroundR * 255.0f), int(mBackgroundG * 255.0f), int(mBackgroundB * 255.0f) );
@@ -511,6 +530,19 @@ private:
                 sendMessage(message);
         }
         
+
+        ////////////////////////////////////////////////////////////////////////////////
+        // virtual
+        void onCookieChanged(const EventType& event)
+        {
+                LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "cookie_set");
+                message.setValue("cookie", event.getStringValue());
+                // These could be passed through as well, but aren't really needed.
+//              message.setValue("uri", event.getEventUri());
+//              message.setValueBoolean("dead", (event.getIntValue() != 0))
+                sendMessage(message);
+        }
+        
         LLQtWebKit::EKeyboardModifier decodeModifiers(std::string &modifiers)
         {
                 int result = 0;
@@ -1056,6 +1088,10 @@ void MediaPluginWebKit::receiveMessage(const char *message_string)
                                 mJavascriptEnabled = message_in.getValueBoolean("enable");
                                 //LLQtWebKit::getInstance()->enableJavascript( mJavascriptEnabled );
                         }
+                        else if(message_name == "set_cookies")
+                        {
+                                LLQtWebKit::getInstance()->setCookies(message_in.getValue("cookies"));
+                        }
                         else if(message_name == "proxy_setup")
                         {
                                 bool val = message_in.getValueBoolean("enable");
@@ -1125,9 +1161,7 @@ void MediaPluginWebKit::receiveMessage(const char *message_string)
 
 void MediaPluginWebKit::setVolume(F32 volume)
 {
-#if LL_LINUX
-        mLinuxVolumeCatcher.setVolume(volume);
-#endif // LL_LINUX
+        mVolumeCatcher.setVolume(volume);
 }
 
 int init_media_plugin(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data)
diff --git a/linden/indra/media_plugins/webkit/volume_catcher.h b/linden/indra/media_plugins/webkit/volume_catcher.h
new file mode 100644
index 0000000..855e99f
--- /dev/null
+++ b/linden/indra/media_plugins/webkit/volume_catcher.h
@@ -0,0 +1,61 @@
+/** 
+ * @file volume_catcher.h
+ * @brief Interface to a class with platform-specific implementations that allows control of the audio volume of all sources in the current process.
+ *
+ * @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 VOLUME_CATCHER_H
+#define VOLUME_CATCHER_H
+
+#include "linden_common.h"
+
+class VolumeCatcherImpl;
+
+class VolumeCatcher
+{
+ public:
+        VolumeCatcher();
+        ~VolumeCatcher();
+
+        void setVolume(F32 volume); // 0.0 - 1.0
+        
+        // Set the left-right pan of audio sources
+        // where -1.0 = left, 0 = center, and 1.0 = right
+        void setPan(F32 pan); 
+
+        void pump(); // call this at least a few times a second if you can - it affects how quickly we can 'catch' a new audio source and adjust its volume
+        
+ private:
+        VolumeCatcherImpl *pimpl;
+};
+
+#endif // VOLUME_CATCHER_H
diff --git a/linden/indra/media_plugins/webkit/windows_volume_catcher.cpp b/linden/indra/media_plugins/webkit/windows_volume_catcher.cpp
new file mode 100644
index 0000000..c02e7fc
--- /dev/null
+++ b/linden/indra/media_plugins/webkit/windows_volume_catcher.cpp
@@ -0,0 +1,124 @@
+/** 
+ * @file windows_volume_catcher.cpp
+ * @brief A Windows implementation of volume level control of all audio channels opened by a process.
+ *
+ * @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 "volume_catcher.h"
+#include <windows.h>
+#include "llsingleton.h"
+class VolumeCatcherImpl : public LLSingleton<VolumeCatcherImpl>
+{
+friend LLSingleton<VolumeCatcherImpl>;
+public:
+
+        void setVolume(F32 volume);
+        void setPan(F32 pan);
+        
+private:
+        // This is a singleton class -- both callers and the component implementation should use getInstance() to find the instance.
+        VolumeCatcherImpl();
+        ~VolumeCatcherImpl();
+
+        typedef void (WINAPI *set_volume_func_t)(F32);
+        typedef void (WINAPI *set_mute_func_t)(bool);
+
+        set_volume_func_t mSetVolumeFunc;
+        set_mute_func_t mSetMuteFunc;
+
+        F32     mVolume;
+        F32     mPan;
+};
+VolumeCatcherImpl::VolumeCatcherImpl()
+:       mVolume(1.0f),  // default volume is max
+        mPan(0.f)               // default pan is centered
+{
+        HMODULE handle = ::LoadLibrary(L"winmm.dll");
+        if(handle)
+        {
+                mSetVolumeFunc = (set_volume_func_t)::GetProcAddress(handle, "setPluginVolume");
+                mSetMuteFunc = (set_mute_func_t)::GetProcAddress(handle, "setPluginMute");
+        }
+}
+
+VolumeCatcherImpl::~VolumeCatcherImpl()
+{
+}
+
+
+void VolumeCatcherImpl::setVolume(F32 volume)
+{
+        mVolume = volume;
+
+        if (mSetMuteFunc)
+        {
+                mSetMuteFunc(volume == 0.f);
+        }
+        if (mSetVolumeFunc)
+        {
+                mSetVolumeFunc(mVolume);
+        }
+}
+
+void VolumeCatcherImpl::setPan(F32 pan)
+{       // remember pan for calculating individual channel levels later
+        mPan = pan;
+}
+
+/////////////////////////////////////////////////////
+
+VolumeCatcher::VolumeCatcher()
+{
+        pimpl = VolumeCatcherImpl::getInstance();
+}
+
+VolumeCatcher::~VolumeCatcher()
+{
+        // Let the instance persist until exit.
+}
+
+void VolumeCatcher::setVolume(F32 volume)
+{
+        pimpl->setVolume(volume);
+}
+
+void VolumeCatcher::setPan(F32 pan)
+{
+        pimpl->setPan(pan);
+}
+
+void VolumeCatcher::pump()
+{
+        // No periodic tasks are necessary for this implementation.
+}
+
+