Merge branch 'weekly' into branding

Conflicts (solved):
	linden/indra/media_plugins/gstreamer010/media_plugin_gstreamer010.cpp
	linden/indra/newview/llappviewer.cpp
	linden/indra/newview/llappviewerwin32.cpp

179 files changed, 5273 insertions, 1853 deletions

diff --git a/linden/doc/contributions.txt b/linden/doc/contributions.txt
index 41f896f..d18b5ba 100644
--- a/linden/doc/contributions.txt
+++ b/linden/doc/contributions.txt
@@ -80,6 +80,7 @@ Aleric Inglewood
         IMP-578
         IMP-579
         IMP-581
+        IMP-590
         IMP-592
         IMP-595
         IMP-660
@@ -91,6 +92,8 @@ Aleric Inglewood
         IMP-670
         IMP-688
         IMP-692
+        IMP-701
+        IMP-712
 Alissa Sabre
         VWR-81
         VWR-83
@@ -339,6 +342,8 @@ Khyota Wulluf
 Kunnis Basiat
         VWR-82
         VWR-102
+Lance Corrimal
+        SNOW-717
 Lisa Lowe
         CT-218
         CT-219
diff --git a/linden/etc/message.xml b/linden/etc/message.xml
index 0fdf364..8d34dd8 100644
--- a/linden/etc/message.xml
+++ b/linden/etc/message.xml
@@ -386,7 +386,17 @@
           <boolean>true</boolean>
         </map>
 
-        <key>ParcelVoiceInfo</key>
+                                <!-- Server to client -->
+                                <key>DisplayNameUpdate</key>
+                                <map>
+                                        <key>flavor</key>
+                                        <string>llsd</string>
+                                        <key>trusted-sender</key>
+                                        <boolean>true</boolean>
+                                </map>
+
+
+                                <key>ParcelVoiceInfo</key>
                                 <map>
                                         <key>flavor</key>
                                         <string>llsd</string>
@@ -442,6 +452,14 @@
           <boolean>true</boolean>
         </map>
 
+        <key>SetDisplayNameReply</key>
+        <map>
+          <key>flavor</key>
+          <string>llsd</string>
+          <key>trusted-sender</key>
+          <boolean>true</boolean>
+        </map>
+
         <key>DirLandReply</key>
         <map>
           <key>flavor</key>
diff --git a/linden/indra/cmake/Boost.cmake b/linden/indra/cmake/Boost.cmake
index 7741615..665a162 100644
--- a/linden/indra/cmake/Boost.cmake
+++ b/linden/indra/cmake/Boost.cmake
@@ -14,7 +14,7 @@ else (STANDALONE)
   set(Boost_INCLUDE_DIRS ${LIBS_PREBUILT_DIR}/include)
 
   if (WINDOWS)
-    set(BOOST_VERSION 1_36)
+    set(BOOST_VERSION 1_39)
     if (MSVC80)
       set(BOOST_PROGRAM_OPTIONS_LIBRARY 
           optimized libboost_program_options-vc80-mt-${BOOST_VERSION}
@@ -25,6 +25,8 @@ else (STANDALONE)
       set(BOOST_SIGNALS_LIBRARY 
           optimized libboost_signals-vc80-mt-${BOOST_VERSION}
           debug libboost_signals-vc80-mt-gd-${BOOST_VERSION})
+        # Default support for VS2008 was lost in the move from 1.36 to 1.39.  
+        # Remove this comment when this is fixed -- MC
     elseif (MSVC90)
       set(BOOST_PROGRAM_OPTIONS_LIBRARY 
           optimized libboost_program_options-vc90-mt-${BOOST_VERSION}
diff --git a/linden/indra/cmake/GStreamer010Plugin.cmake b/linden/indra/cmake/GStreamer010Plugin.cmake
index 90ed35c..ec9b828 100644
--- a/linden/indra/cmake/GStreamer010Plugin.cmake
+++ b/linden/indra/cmake/GStreamer010Plugin.cmake
@@ -15,11 +15,19 @@ else (STANDALONE)
   use_prebuilt_binary(gstreamer)
   set(GSTREAMER010_FOUND ON FORCE BOOL)
   set(GSTREAMER010_PLUGINS_BASE_FOUND ON FORCE BOOL)
-  set(GSTREAMER010_INCLUDE_DIRS
-      ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/include/gstreamer-0.10
-      ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/include/glib-2.0
-      ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/include/libxml2
-      )
+  if (WINDOWS)
+    set(GSTREAMER010_INCLUDE_DIRS
+                ${LIBS_PREBUILT_DIR}/include/gstreamer-0.10
+                ${LIBS_PREBUILT_DIR}/include/glib
+                ${LIBS_PREBUILT_DIR}/include/libxml2
+                )
+  else (WINDOWS)
+        set(GSTREAMER010_INCLUDE_DIRS
+                ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/include/gstreamer-0.10
+                ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/include/glib-2.0
+                ${LIBS_PREBUILT_DIR}/${LL_ARCH_DIR}/include/libxml2
+                )
+  endif (WINDOWS)
 
 endif (STANDALONE)
 
@@ -27,10 +35,10 @@ if (WINDOWS)
   # We don't need to explicitly link against gstreamer itself, because
   # LLMediaImplGStreamer probes for the system's copy at runtime.
     set(GSTREAMER010_LIBRARIES
-         libgstvideo
-         libgstaudio
-         libgstbase-0.10
-         libgstreamer-0.10
+         gstaudio-0.10.lib
+         gstbase-0.10.lib
+         gstreamer-0.10.lib
+         gstvideo-0.10.lib
          gobject-2.0
          gmodule-2.0
          gthread-2.0
diff --git a/linden/indra/llaudio/llaudioengine.cpp b/linden/indra/llaudio/llaudioengine.cpp
index bed791a..6b0003a 100644
--- a/linden/indra/llaudio/llaudioengine.cpp
+++ b/linden/indra/llaudio/llaudioengine.cpp
@@ -36,7 +36,6 @@
 #include "linden_common.h"
 
 #include "llaudioengine.h"
-#include "llstreamingaudio.h"
 
 #include "llerror.h"
 #include "llmath.h"
@@ -48,7 +47,6 @@
 #include "llaudiodecodemgr.h"
 #include "llassetstorage.h"
 
-
 // necessary for grabbing sounds from sim (implemented in viewer)       
 extern void request_sound(const LLUUID &sound_guid);
 
@@ -70,16 +68,6 @@ LLAudioEngine::~LLAudioEngine()
 {
 }
 
-LLStreamingAudioInterface* LLAudioEngine::getStreamingAudioImpl()
-{
-        return mStreamingAudioImpl;
-}
-
-void LLAudioEngine::setStreamingAudioImpl(LLStreamingAudioInterface *impl)
-{
-        mStreamingAudioImpl = impl;
-}
-
 void LLAudioEngine::setDefaults()
 {
         mMaxWindGain = 1.f;
@@ -108,8 +96,6 @@ void LLAudioEngine::setDefaults()
         mInternalGain = 0.f;
         mNextWindUpdate = 0.f;
 
-        mStreamingAudioImpl = NULL;
-
         for (U32 i = 0; i < LLAudioEngine::AUDIO_TYPE_COUNT; i++)
                 mSecondaryGain[i] = 1.0f;
 }
@@ -174,62 +160,6 @@ void LLAudioEngine::shutdown()
         }
 }
 
-
-// virtual
-void LLAudioEngine::startInternetStream(const std::string& url)
-{
-        if (mStreamingAudioImpl)
-                mStreamingAudioImpl->start(url);
-}
-
-
-// virtual
-void LLAudioEngine::stopInternetStream()
-{
-        if (mStreamingAudioImpl)
-                mStreamingAudioImpl->stop();
-}
-
-// virtual
-void LLAudioEngine::pauseInternetStream(int pause)
-{
-        if (mStreamingAudioImpl)
-                mStreamingAudioImpl->pause(pause);
-}
-
-// virtual
-void LLAudioEngine::updateInternetStream()
-{
-        if (mStreamingAudioImpl)
-                mStreamingAudioImpl->update();
-}
-
-// virtual
-int LLAudioEngine::isInternetStreamPlaying()
-{
-        if (mStreamingAudioImpl)
-                return mStreamingAudioImpl->isPlaying();
-
-        return 0; // Stopped
-}
-
-
-// virtual
-void LLAudioEngine::setInternetStreamGain(F32 vol)
-{
-        if (mStreamingAudioImpl)
-                mStreamingAudioImpl->setGain(vol);
-}
-
-// virtual
-std::string LLAudioEngine::getInternetStreamURL()
-{
-        if (mStreamingAudioImpl)
-                return mStreamingAudioImpl->getURL();
-        else return std::string();
-}
-
-
 void LLAudioEngine::updateChannels()
 {
         S32 i;
@@ -512,7 +442,6 @@ void LLAudioEngine::idle(F32 max_decode_time)
         // or request new data.
         startNextTransfer();
 
-        updateInternetStream();
 }
 
 
@@ -754,14 +683,6 @@ F32 LLAudioEngine::getSecondaryGain(S32 type)
         return mSecondaryGain[type];
 }
 
-F32 LLAudioEngine::getInternetStreamGain()
-{
-        if (mStreamingAudioImpl)
-                return mStreamingAudioImpl->getGain();
-        else
-                return 1.0f;
-}
-
 void LLAudioEngine::setMaxWindGain(F32 gain)
 {
         mMaxWindGain = gain;
diff --git a/linden/indra/llaudio/llaudioengine.h b/linden/indra/llaudio/llaudioengine.h
index a1b240e..7237ce2 100644
--- a/linden/indra/llaudio/llaudioengine.h
+++ b/linden/indra/llaudio/llaudioengine.h
@@ -71,8 +71,6 @@ class LLAudioData;
 class LLAudioChannel;
 class LLAudioChannelOpenAL;
 class LLAudioBuffer;
-class LLStreamingAudioInterface;
-
 
 //
 //  LLAudioEngine definition
@@ -119,16 +117,13 @@ public:
         // stops playing new sounds.
         void setMuted(bool muted);
         bool getMuted() const { return mMuted; }
-#ifdef USE_PLUGIN_MEDIA
-        LLPluginClassMedia* initializeMedia(const std::string& media_type);
-#endif
+
         F32 getMasterGain();
         void setMasterGain(F32 gain);
 
         F32 getSecondaryGain(S32 type);
         void setSecondaryGain(S32 type, F32 gain);
 
-        F32 getInternetStreamGain();
 
         virtual void setDopplerFactor(F32 factor);
         virtual F32 getDopplerFactor();
@@ -150,19 +145,6 @@ public:
         LLAudioSource *findAudioSource(const LLUUID &source_id);
         LLAudioData *getAudioData(const LLUUID &audio_uuid);
 
-        // Internet stream implementation manipulation
-        LLStreamingAudioInterface *getStreamingAudioImpl();
-        void setStreamingAudioImpl(LLStreamingAudioInterface *impl);
-        // Internet stream methods - these will call down into the *mStreamingAudioImpl if it exists
-        void startInternetStream(const std::string& url);
-        void stopInternetStream();
-        void pauseInternetStream(int pause);
-        void updateInternetStream(); // expected to be called often
-        int isInternetStreamPlaying();
-        // use a value from 0.0 to 1.0, inclusive
-        void setInternetStreamGain(F32 vol);
-        std::string getInternetStreamURL();
-        
         // For debugging usage
         virtual LLVector3 getListenerPos();
 
@@ -247,7 +229,6 @@ protected:
 
 private:
         void setDefaults();
-        LLStreamingAudioInterface *mStreamingAudioImpl;
 };
 
 
diff --git a/linden/indra/llaudio/llstreamingaudio.h b/linden/indra/llaudio/llstreamingaudio.h
index aa89e6a..f5d5334 100644
--- a/linden/indra/llaudio/llstreamingaudio.h
+++ b/linden/indra/llaudio/llstreamingaudio.h
@@ -36,7 +36,7 @@
 
 #include "stdtypes.h" // from llcommon
 
-// Entirely abstract.  Based exactly on the historic API.
+// Entirely abstract.  Based on the historic API.
 class LLStreamingAudioInterface
 {
  public:
@@ -51,6 +51,7 @@ class LLStreamingAudioInterface
         virtual void setGain(F32 vol) = 0;
         virtual F32 getGain() = 0;
         virtual std::string getURL() = 0;
+        virtual std::string getVersion() = 0;
 };
 
 #endif // LL_STREAMINGAUDIO_H
diff --git a/linden/indra/llcharacter/llcharacter.cpp b/linden/indra/llcharacter/llcharacter.cpp
index 46ac326..72cef83 100644
--- a/linden/indra/llcharacter/llcharacter.cpp
+++ b/linden/indra/llcharacter/llcharacter.cpp
@@ -379,7 +379,7 @@ void LLCharacter::clearVisualParamWeights()
                 param;
                 param = getNextVisualParam())
         {
-                if (param->getGroup() == VISUAL_PARAM_GROUP_TWEAKABLE)
+                if (param->isTweakable())
                 {
                         param->setWeight( param->getDefaultWeight(), FALSE );
                 }
@@ -395,7 +395,7 @@ BOOL LLCharacter::visualParamWeightsAreDefault()
                 param;
                 param = getNextVisualParam())
         {
-                if (param->getGroup() == VISUAL_PARAM_GROUP_TWEAKABLE)
+                if (param->isTweakable())
                 {
                         if (param->getWeight() != param->getDefaultWeight())
                                 return false;
diff --git a/linden/indra/llcharacter/llcharacter.h b/linden/indra/llcharacter/llcharacter.h
index d91124b..7630760 100644
--- a/linden/indra/llcharacter/llcharacter.h
+++ b/linden/indra/llcharacter/llcharacter.h
@@ -231,6 +231,20 @@ public:
                 return (mCurIterator++)->second;
         }
 
+        S32 getVisualParamCountInGroup(EVisualParamGroup group)
+        {
+                S32 rtn = 0;
+                VisualParamIndexMap_t::iterator iter;
+                for (iter = mVisualParamIndexMap.begin(); iter != mVisualParamIndexMap.end(); iter++)
+                {
+                        if (iter->second->getGroup() == group)
+                        {
+                                rtn++;
+                        }
+                }
+                return rtn;
+        }
+
         LLVisualParam*  getVisualParam(S32 id)
         {
                 VisualParamIndexMap_t::iterator iter = mVisualParamIndexMap.find(id);
diff --git a/linden/indra/llcharacter/llvisualparam.cpp b/linden/indra/llcharacter/llvisualparam.cpp
index d7a144e..9579ff8 100644
--- a/linden/indra/llcharacter/llvisualparam.cpp
+++ b/linden/indra/llcharacter/llvisualparam.cpp
@@ -238,7 +238,7 @@ void LLVisualParam::setAnimationTarget(F32 target_value, BOOL set_by_user)
 {
         if (mInfo)
         {
-                if (getGroup() == VISUAL_PARAM_GROUP_TWEAKABLE)
+                if (isTweakable())
                 {
                         mTargetWeight = llclamp(target_value, mInfo->mMinWeight, mInfo->mMaxWeight);
                 }
@@ -282,7 +282,7 @@ void LLVisualParam::animate( F32 delta, BOOL set_by_user )
 //-----------------------------------------------------------------------------
 void LLVisualParam::stopAnimating(BOOL set_by_user)
 { 
-        if (mIsAnimating && getGroup() == VISUAL_PARAM_GROUP_TWEAKABLE)
+        if (mIsAnimating && isTweakable())
         {
                 mIsAnimating = FALSE; 
                 setWeight(mTargetWeight, set_by_user);
diff --git a/linden/indra/llcharacter/llvisualparam.h b/linden/indra/llcharacter/llvisualparam.h
index 3a0c1bb..d8dff8c 100644
--- a/linden/indra/llcharacter/llvisualparam.h
+++ b/linden/indra/llcharacter/llvisualparam.h
@@ -51,6 +51,7 @@ enum EVisualParamGroup
 {
         VISUAL_PARAM_GROUP_TWEAKABLE,
         VISUAL_PARAM_GROUP_ANIMATABLE,
+        VISUAL_PARAM_GROUP_TWEAKABLE_NO_TRANSMIT,
         NUM_VISUAL_PARAM_GROUPS
 };
 
@@ -124,7 +125,7 @@ public:
         void                                    setMaxDisplayName(const std::string& s) { mInfo->mMaxName = s; }
         void                                    setMinDisplayName(const std::string& s) { mInfo->mMinName = s; }
 
-        EVisualParamGroup               getGroup()                      { return mInfo->mGroup; }
+        EVisualParamGroup               getGroup() const        { return mInfo->mGroup; }
         F32                                             getMinWeight()          { return mInfo->mMinWeight; }
         F32                                             getMaxWeight()          { return mInfo->mMaxWeight; }
         F32                                             getDefaultWeight()      { return mInfo->mDefaultWeight; }
@@ -133,7 +134,8 @@ public:
         F32                                             getWeight()             { return mIsAnimating ? mTargetWeight : mCurWeight; }
         F32                                             getCurrentWeight()      { return mCurWeight; }
         F32                                             getLastWeight()         { return mLastWeight; }
-        BOOL                                    isAnimating()   { return mIsAnimating; }
+        BOOL                                    isAnimating()           { return mIsAnimating; }
+        BOOL                                    isTweakable()           { return (getGroup() == VISUAL_PARAM_GROUP_TWEAKABLE)  || (getGroup() == VISUAL_PARAM_GROUP_TWEAKABLE_NO_TRANSMIT); }
 
         LLVisualParam*                  getNextParam()          { return mNext; }
         void                                    setNextParam( LLVisualParam *next );
@@ -141,6 +143,7 @@ public:
         virtual void                    setAnimating(BOOL is_animating) { mIsAnimating = is_animating; }
         BOOL                                    getAnimating() { return mIsAnimating; }
 
+
 protected:
         F32                                     mCurWeight;                     // current weight
         F32                                     mLastWeight;            // last weight
diff --git a/linden/indra/llcommon/CMakeLists.txt b/linden/indra/llcommon/CMakeLists.txt
index ff1d548..ed04ca6 100644
--- a/linden/indra/llcommon/CMakeLists.txt
+++ b/linden/indra/llcommon/CMakeLists.txt
@@ -13,11 +13,13 @@ include_directories(
     )
 
 set(llcommon_SOURCE_FILES
+    aiaprpool.cpp
     imageids.cpp
     indra_constants.cpp
     llapp.cpp
     llapr.cpp
     llassettype.cpp
+    llavatarname.cpp
     llbase32.cpp
     llbase64.cpp
     llcommon.cpp
@@ -74,6 +76,8 @@ set(llcommon_SOURCE_FILES
 set(llcommon_HEADER_FILES
     CMakeLists.txt
 
+    aiaprpool.h
+    aithreadsafe.h
     bitpack.h
     ctype_workaround.h
     doublelinkedlist.h
@@ -87,6 +91,7 @@ set(llcommon_HEADER_FILES
     llassettype.h
     llassoclist.h
     llavatarconstants.h
+    llavatarname.h
     llbase32.h
     llbase64.h
     llboost.h
@@ -147,6 +152,7 @@ set(llcommon_HEADER_FILES
     llqueuedthread.h
     llrand.h
     llrun.h
+    llscopedvolatileaprpool.h
     llsd.h
     llsdserialize.h
     llsdserialize_xml.h
diff --git a/linden/indra/llcommon/aiaprpool.cpp b/linden/indra/llcommon/aiaprpool.cpp
new file mode 100644
index 0000000..d3748e9
--- /dev/null
+++ b/linden/indra/llcommon/aiaprpool.cpp
@@ -0,0 +1,198 @@
+/**
+ * @file aiaprpool.cpp
+ *
+ * Copyright (c) 2010, Aleric Inglewood.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * 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.
+ *
+ * CHANGELOG
+ *   and additional copyright holders.
+ *
+ *   04/04/2010
+ *   - Initial version, written by Aleric Inglewood @ SL
+ *
+ *   10/11/2010
+ *   - Changed filename, class names and license to a more
+ *     company-neutral format.
+ *   - Added APR_HAS_THREADS #if's to allow creation and destruction
+ *     of subpools by threads other than the parent pool owner.
+ */
+
+#include "linden_common.h"
+
+#include "llerror.h"
+#include "aiaprpool.h"
+#include "llthread.h"
+
+// Create a subpool from parent.
+void AIAPRPool::create(AIAPRPool& parent)
+{
+        llassert(!mPool);                       // Must be non-initialized.
+        mParent = &parent;
+        if (!mParent)                           // Using the default parameter?
+        {
+                // By default use the root pool of the current thread.
+                mParent = &AIThreadLocalData::tldata().mRootPool;
+        }
+        llassert(mParent->mPool);       // Parent must be initialized.
+#if APR_HAS_THREADS
+        // As per the documentation of APR (ie http://apr.apache.org/docs/apr/1.4/apr__pools_8h.html):
+        //
+        // Note that most operations on pools are not thread-safe: a single pool should only be
+        // accessed by a single thread at any given time. The one exception to this rule is creating
+        // a subpool of a given pool: one or more threads can safely create subpools at the same
+        // time that another thread accesses the parent pool.
+        //
+        // In other words, it's safe for any thread to create a (sub)pool, independent of who
+        // owns the parent pool.
+        mOwner = apr_os_thread_current();
+#else
+        mOwner = mParent->mOwner;
+        llassert(apr_os_thread_equal(mOwner, apr_os_thread_current()));
+#endif
+        apr_status_t const apr_pool_create_status = apr_pool_create(&mPool, mParent->mPool);
+        llassert_always(apr_pool_create_status == APR_SUCCESS);
+        llassert(mPool);                        // Initialized.
+        apr_pool_cleanup_register(mPool, this, &s_plain_cleanup, &apr_pool_cleanup_null);
+}
+
+// Destroy the (sub)pool, if any.
+void AIAPRPool::destroy(void)
+{
+        // Only do anything if we are not already (being) destroyed.
+        if (mPool)
+        {
+#if !APR_HAS_THREADS
+                // If we are a root pool, then every thread may destruct us: in that case
+                // we have to assume that no other thread will use this pool concurrently,
+                // of course. Otherwise, if we are a subpool, only the thread that owns
+                // the parent may destruct us, since that is the pool that is still alive,
+                // possibly being used by others and being altered here.
+                llassert(!mParent || apr_os_thread_equal(mParent->mOwner, apr_os_thread_current()));
+#endif
+                apr_pool_t* pool = mPool;
+                mPool = NULL;                           // Mark that we are BEING destructed.
+                apr_pool_cleanup_kill(pool, this, &s_plain_cleanup);
+                apr_pool_destroy(pool);
+        }
+}
+
+bool AIAPRPool::parent_is_being_destructed(void)
+{
+        return mParent && (!mParent->mPool || mParent->parent_is_being_destructed());
+}
+
+AIAPRInitialization::AIAPRInitialization(void)
+{
+        static bool apr_initialized = false;
+
+        if (!apr_initialized)
+        {
+                apr_initialize();
+        }
+
+        apr_initialized = true;
+}
+
+bool AIAPRRootPool::sCountInitialized = false;
+apr_uint32_t volatile AIAPRRootPool::sCount;
+
+extern apr_thread_mutex_t* gLogMutexp;
+extern apr_thread_mutex_t* gCallStacksLogMutexp;
+
+AIAPRRootPool::AIAPRRootPool(void) : AIAPRInitialization(), AIAPRPool(0)
+{
+        // sCountInitialized don't need locking because when we get here there is still only a single thread.
+        if (!sCountInitialized)
+        {
+                // Initialize the logging mutex
+                apr_thread_mutex_create(&gLogMutexp, APR_THREAD_MUTEX_UNNESTED, mPool);
+                apr_thread_mutex_create(&gCallStacksLogMutexp, APR_THREAD_MUTEX_UNNESTED, mPool);
+
+                apr_status_t status = apr_atomic_init(mPool);
+                llassert_always(status == APR_SUCCESS);
+                apr_atomic_set32(&sCount, 1);   // Set to 1 to account for the global root pool.
+                sCountInitialized = true;
+
+                // Initialize thread-local APR pool support.
+                // Because this recursively calls AIAPRRootPool::AIAPRRootPool(void)
+                // it must be done last, so that sCount is already initialized.
+                AIThreadLocalData::init();
+        }
+        apr_atomic_inc32(&sCount);
+}
+
+AIAPRRootPool::~AIAPRRootPool()
+{
+        if (!apr_atomic_dec32(&sCount))
+        {
+                // The last pool was destructed. Cleanup remainder of APR.
+                LL_INFOS("APR") << "Cleaning up APR" << LL_ENDL;
+
+                if (gLogMutexp)
+                {
+                        // Clean up the logging mutex
+
+                        // All other threads NEED to be done before we clean up APR, so this is okay.
+                        apr_thread_mutex_destroy(gLogMutexp);
+                        gLogMutexp = NULL;
+                }
+                if (gCallStacksLogMutexp)
+                {
+                        // Clean up the logging mutex
+
+                        // All other threads NEED to be done before we clean up APR, so this is okay.
+                        apr_thread_mutex_destroy(gCallStacksLogMutexp);
+                        gCallStacksLogMutexp = NULL;
+                }
+
+                // Must destroy ALL, and therefore this last AIAPRRootPool, before terminating APR.
+                static_cast<AIAPRRootPool*>(this)->destroy();
+
+                apr_terminate();
+        }
+}
+
+//static
+AIAPRRootPool& AIAPRRootPool::get(void)
+{
+  static AIAPRRootPool global_APRpool(0);               // This is what used to be gAPRPoolp.
+  return global_APRpool;
+}
+
+void AIVolatileAPRPool::clearVolatileAPRPool()
+{
+        llassert_always(mNumActiveRef > 0);
+        if (--mNumActiveRef == 0)
+        {
+                if (isOld())
+                {
+                        destroy();
+                        mNumTotalRef = 0 ;
+                }
+                else
+                {
+                        // This does not actually free the memory,
+                        // it just allows the pool to re-use this memory for the next allocation.
+                        clear();
+                }
+        }
+
+        // Paranoia check if the pool is jammed.
+        llassert(mNumTotalRef < (FULL_VOLATILE_APR_POOL << 2)) ;
+}
diff --git a/linden/indra/llcommon/aiaprpool.h b/linden/indra/llcommon/aiaprpool.h
new file mode 100644
index 0000000..ac523a9
--- /dev/null
+++ b/linden/indra/llcommon/aiaprpool.h
@@ -0,0 +1,240 @@
+/**
+ * @file aiaprpool.h
+ * @brief Implementation of AIAPRPool.
+ *
+ * Copyright (c) 2010, Aleric Inglewood.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * 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.
+ *
+ * CHANGELOG
+ *   and additional copyright holders.
+ *
+ *   04/04/2010
+ *   - Initial version, written by Aleric Inglewood @ SL
+ *
+ *   10/11/2010
+ *   - Changed filename, class names and license to a more
+ *     company-neutral format.
+ *   - Added APR_HAS_THREADS #if's to allow creation and destruction
+ *     of subpools by threads other than the parent pool owner.
+ */
+
+#ifndef AIAPRPOOL_H
+#define AIAPRPOOL_H
+
+#ifdef LL_WINDOWS
+//#include <ws2tcpip.h>         
+# define WIN32_LEAN_AND_MEAN
+# include <winsock2.h> // Needed before including apr_portable.h
+#endif
+
+#include "apr_portable.h"
+#include "apr_pools.h"
+#include "llerror.h"
+
+extern void ll_init_apr();
+
+/**
+ * @brief A wrapper around the APR memory pool API.
+ *
+ * Usage of this class should be restricted to passing it to libapr-1 function calls that need it.
+ *
+ */
+class LL_COMMON_API AIAPRPool
+{
+protected:
+        apr_pool_t* mPool;                                      //!< Pointer to the underlaying pool. NULL if not initialized.
+        AIAPRPool* mParent;                     //!< Pointer to the parent pool, if any. Only valid when mPool is non-zero.
+        apr_os_thread_t mOwner;                         //!< The thread that owns this memory pool. Only valid when mPool is non-zero.
+
+public:
+        //! Construct an uninitialized (destructed) pool.
+        AIAPRPool(void) : mPool(NULL) { }
+
+    //! Construct a subpool from an existing pool.
+        // This is not a copy-constructor, this class doesn't have one!
+        AIAPRPool(AIAPRPool& parent) : mPool(NULL) { create(parent); }
+
+        //! Destruct the memory pool (free all of it's subpools and allocated memory).
+        ~AIAPRPool() { destroy(); }
+
+protected:
+        // Create a pool that is allocated from the Operating System. Only used by AIAPRRootPool.
+        AIAPRPool(int) : mPool(NULL), mParent(NULL), mOwner(apr_os_thread_current())
+        {
+                apr_status_t const apr_pool_create_status = apr_pool_create(&mPool, NULL);
+                llassert_always(apr_pool_create_status == APR_SUCCESS);
+                llassert(mPool);
+                apr_pool_cleanup_register(mPool, this, &s_plain_cleanup, &apr_pool_cleanup_null);
+        }
+
+public:
+        //! Create a subpool from parent. May only be called for an uninitialized/destroyed pool.
+        // The default parameter causes the root pool of the current thread to be used.
+        void create(AIAPRPool& parent = *static_cast<AIAPRPool*>(NULL));
+
+        //! Destroy the (sub)pool, if any.
+        void destroy(void);
+
+        // Use some safebool idiom (http://www.artima.com/cppsource/safebool.html) rather than operator bool.
+        typedef apr_pool_t* const AIAPRPool::* const bool_type;
+        //! Return true if the pool is initialized.
+        operator bool_type() const { return mPool ? &AIAPRPool::mPool : 0; }
+
+        // Painful, but we have to either provide access to this, or wrap
+        // every APR function call that needs a apr_pool_t* to be passed.
+        // NEVER destroy a pool that is returned by this function!
+        apr_pool_t* operator()(void) const
+        {
+                llassert(mPool);
+                llassert(apr_os_thread_equal(mOwner, apr_os_thread_current()));
+                return mPool;
+        }
+
+        // Free all memory without destructing the pool.
+        void clear(void)
+        {
+                llassert(mPool);
+                llassert(apr_os_thread_equal(mOwner, apr_os_thread_current()));
+                apr_pool_clear(mPool);
+        }
+
+// These methods would make this class 'complete' (as wrapper around the libapr
+// pool functions), but we don't use memory pools in the viewer (only when
+// we are forced to pass one to a libapr call), so don't define them in order
+// not to encourage people to use them.
+#if 0
+        void* palloc(size_t size)
+        {
+                llassert(mPool);
+                llassert(apr_os_thread_equal(mOwner, apr_os_thread_current()));
+                return apr_palloc(mPool, size);
+        }
+        void* pcalloc(size_t size)
+        {
+                llassert(mPool);
+                llassert(apr_os_thread_equal(mOwner, apr_os_thread_current()));
+                return apr_pcalloc(mPool, size);
+        }
+#endif
+
+private:
+        bool parent_is_being_destructed(void);
+        static apr_status_t s_plain_cleanup(void* userdata) { return static_cast<AIAPRPool*>(userdata)->plain_cleanup(); }
+
+        apr_status_t plain_cleanup(void)
+        {
+                if (mPool &&                                            // We are not being destructed,
+                        parent_is_being_destructed())   // but our parent is.
+                  // This means the pool is being destructed recursively by libapr
+                  // because one of it's parents is being destructed.
+                {
+                        mPool = NULL;   // Stop destroy() from destructing the pool again.
+                }
+                return APR_SUCCESS;
+        }
+};
+
+class AIAPRInitialization
+{
+public:
+        AIAPRInitialization(void);
+};
+
+/**
+ * @brief Root memory pool (allocates memory from the operating system).
+ *
+ * This class should only be used by AIThreadLocalData and AIThreadSafeSimpleDCRootPool_pbase
+ * (and LLMutexRootPool when APR_HAS_THREADS isn't defined).
+ */
+class LL_COMMON_API AIAPRRootPool : public AIAPRInitialization, public AIAPRPool
+{
+private:
+        friend class AIThreadLocalData;
+        friend class AIThreadSafeSimpleDCRootPool_pbase;
+#if !APR_HAS_THREADS
+        friend class LLMutexRootPool;
+#endif
+        //! Construct a root memory pool.
+        //  Should only be used by AIThreadLocalData and AIThreadSafeSimpleDCRootPool_pbase.
+        AIAPRRootPool(void);
+        ~AIAPRRootPool();
+
+private:
+        // Keep track of how many root pools exist and when the last one is destructed.
+        static bool sCountInitialized;
+        static apr_uint32_t volatile sCount;
+
+public:
+        // Return a global root pool that is independent of AIThreadLocalData.
+        // Normally you should not use this. Only use for early initialization
+        // (before main) and deinitialization (after main).
+        static AIAPRRootPool& get(void);
+
+#if APR_POOL_DEBUG
+        void grab_ownership(void)
+        {
+                // You need a patched libapr to use this.
+                // See http://web.archiveorange.com/archive/v/5XO9y2zoxUOMt6Gmi1OI
+                apr_pool_owner_set(mPool);
+        }
+#endif
+
+private:
+        // Used for constructing the Special Global Root Pool (returned by AIAPRRootPool::get).
+        // It is the same as the default constructor but omits to increment sCount. As a result,
+        // we must be sure that at least one other AIAPRRootPool is created before termination
+        // of the application (which is the case: we create one AIAPRRootPool per thread).
+        AIAPRRootPool(int) : AIAPRInitialization(), AIAPRPool(0) { }
+};
+
+//! Volatile memory pool
+//
+// 'Volatile' APR memory pool which normally only clears memory,
+// and does not destroy the pool (the same pool is reused) for
+// greater efficiency. However, as a safe guard the apr pool
+// is destructed every FULL_VOLATILE_APR_POOL uses to allow
+// the system memory to be allocated more efficiently and not
+// get scattered through RAM.
+//
+class LL_COMMON_API AIVolatileAPRPool : protected AIAPRPool
+{
+public:
+        AIVolatileAPRPool(void) : mNumActiveRef(0), mNumTotalRef(0) { }
+
+        apr_pool_t* getVolatileAPRPool(void)
+        {
+                if (!mPool) create();
+                ++mNumActiveRef;
+                ++mNumTotalRef;
+                return AIAPRPool::operator()();
+        }
+        void clearVolatileAPRPool(void);
+
+        bool isOld(void) const { return mNumTotalRef > FULL_VOLATILE_APR_POOL; }
+        bool isUnused() const { return mNumActiveRef == 0; }
+
+private:
+        S32 mNumActiveRef;      // Number of active uses of the pool.
+        S32 mNumTotalRef;       // Number of total uses of the pool since last creation.
+
+        // Maximum number of references to AIVolatileAPRPool until the pool is recreated.
+        static S32 const FULL_VOLATILE_APR_POOL = 1024;
+};
+
+#endif // AIAPRPOOL_H
diff --git a/linden/indra/llcommon/aithreadsafe.h b/linden/indra/llcommon/aithreadsafe.h
new file mode 100644
index 0000000..e1b93ba
--- /dev/null
+++ b/linden/indra/llcommon/aithreadsafe.h
@@ -0,0 +1,463 @@
+/**
+ * @file aithreadsafe.h
+ * @brief Implementation of AIThreadSafe, AIReadAccessConst, AIReadAccess and AIWriteAccess.
+ *
+ * CHANGELOG
+ *   and additional copyright holders.
+ *
+ *   31/03/2010
+ *   Initial version, written by Aleric Inglewood @ SL
+ */
+
+#ifndef AITHREADSAFE_H
+#define AITHREADSAFE_H
+
+#include <new>
+
+#include "llthread.h"
+#include "llerror.h"
+
+template<typename T> struct AIReadAccessConst;
+template<typename T> struct AIReadAccess;
+template<typename T> struct AIWriteAccess;
+template<typename T> struct AIAccess;
+
+template<typename T>
+class AIThreadSafeBits
+{
+private:
+        // AIThreadSafe is a wrapper around an instance of T.
+        // Because T might not have a default constructor, it is constructed
+        // 'in place', with placement new, in the memory reserved here.
+        //
+        // Make sure that the memory that T will be placed in is properly
+        // aligned by using an array of long's.
+        long mMemory[(sizeof(T) + sizeof(long) - 1) / sizeof(long)];
+
+public:
+        // The wrapped objects are constructed in-place with placement new *outside*
+        // of this object (by AITHREADSAFE macro(s) or derived classes).
+        // However, we are responsible for the destruction of the wrapped object.
+        ~AIThreadSafeBits() { ptr()->~T(); }
+
+        // Only for use by AITHREADSAFE, see below.
+        void* memory() const { return const_cast<long*>(&mMemory[0]); }
+
+protected:
+        // Accessors.
+        T const* ptr() const { return reinterpret_cast<T const*>(mMemory); }
+        T* ptr() { return reinterpret_cast<T*>(mMemory); }
+};
+
+/**
+ * @brief A wrapper class for objects that need to be accessed by more than one thread, allowing concurrent readers.
+ *
+ * Use AITHREADSAFE to define instances of any type, and use AIReadAccessConst,
+ * AIReadAccess and AIWriteAccess to get access to the instance.
+ *
+ * For example,
+ *
+ * <code>
+ * class Foo { public: Foo(int, int); };
+ *
+ * AITHREADSAFE(Foo, foo, (2, 3));
+ *
+ * AIReadAccess<Foo> foo_r(foo);
+ * // Use foo_r-> for read access.
+ *
+ * AIWriteAccess<Foo> foo_w(foo);
+ * // Use foo_w-> for write access.
+ * </code>
+ *
+ * If <code>foo</code> is constant, you have to use <code>AIReadAccessConst<Foo></code>.
+ *
+ * It is possible to pass access objects to a function that
+ * downgrades the access, for example:
+ *
+ * <code>
+ * void readfunc(AIReadAccess const& access);
+ *
+ * AIWriteAccess<Foo> foo_w(foo);
+ * readfunc(foo_w);                                     // readfunc will perform read access to foo_w.
+ * </code>
+ *
+ * If <code>AIReadAccess</code> is non-const, you can upgrade the access by creating
+ * an <code>AIWriteAccess</code> object from it. For example:
+ *
+ * <code>
+ * AIWriteAccess<Foo> foo_w(foo_r);
+ * </code>
+ *
+ * This API is Robust(tm). If you try anything that could result in problems,
+ * it simply won't compile. The only mistake you can still easily make is
+ * to obtain write access to an object when it is not needed, or to unlock
+ * an object in between accesses while the state of the object should be
+ * preserved. For example:
+ *
+ * <code>
+ * // This resets foo to point to the first file and then returns that.
+ * std::string filename = AIWriteAccess<Foo>(foo)->get_first_filename();
+ *
+ * // WRONG! The state between calling get_first_filename and get_next_filename should be preserved!
+ *
+ * AIWriteAccess<Foo> foo_w(foo);       // Wrong. The code below only needs read-access.
+ * while (!filename.empty())
+ * {
+ *     something(filename);
+ *     filename = foo_w->next_filename();
+ * }
+ * </code>
+ *
+ * Correct would be
+ *
+ * <code>
+ * AIReadAccess<Foo> foo_r(foo);
+ * std::string filename = AIWriteAccess<Foo>(foo_r)->get_first_filename();
+ * while (!filename.empty())
+ * {
+ *     something(filename);
+ *     filename = foo_r->next_filename();
+ * }
+ * </code>
+ *
+ */
+template<typename T>
+class AIThreadSafe : public AIThreadSafeBits<T>
+{
+protected:
+        // Only these may access the object (through ptr()).
+        friend struct AIReadAccessConst<T>;
+        friend struct AIReadAccess<T>;
+        friend struct AIWriteAccess<T>;
+
+        // Locking control.
+        AIRWLock mRWLock;
+
+        // For use by AIThreadSafeDC
+        AIThreadSafe(void) { }
+        AIThreadSafe(AIAPRPool& parent) : mRWLock(parent) { }
+
+public:
+        // Only for use by AITHREADSAFE, see below.
+        AIThreadSafe(T* object) { llassert(object == AIThreadSafeBits<T>::ptr()); }
+};
+
+/**
+ * @brief Instantiate an static, global or local object of a given type wrapped in AIThreadSafe, using an arbitrary constructor.
+ *
+ * For example, instead of doing
+ *
+ * <code>
+ * Foo foo(x, y);
+ * static Bar bar;
+ * </code>
+ *
+ * One can instantiate a thread-safe instance with
+ *
+ * <code>
+ * AITHREADSAFE(Foo, foo, (x, y));
+ * static AITHREADSAFE(Bar, bar, );
+ * </code>
+ *
+ * Note: This macro does not allow to allocate such object on the heap.
+ *       If that is needed, have a look at AIThreadSafeDC.
+ */
+#define AITHREADSAFE(type, var, paramlist) AIThreadSafe<type> var(new (var.memory()) type paramlist)
+
+/**
+ * @brief A wrapper class for objects that need to be accessed by more than one thread.
+ *
+ * This class is the same as an AIThreadSafe wrapper, except that it can only
+ * be used for default constructed objects.
+ *
+ * For example, instead of
+ *
+ * <code>
+ * Foo foo;
+ * </code>
+ *
+ * One would use
+ *
+ * <code>
+ * AIThreadSafeDC<Foo> foo;
+ * </code>
+ *
+ * The advantage over AITHREADSAFE is that this object can be allocated with
+ * new on the heap. For example:
+ *
+ * <code>
+ * AIThreadSafeDC<Foo>* ptr = new AIThreadSafeDC<Foo>;
+ * </code>
+ *
+ * which is not possible with AITHREADSAFE.
+ */
+template<typename T>
+class AIThreadSafeDC : public AIThreadSafe<T>
+{
+public:
+        // Construct a wrapper around a default constructed object.
+        AIThreadSafeDC(void) { new (AIThreadSafe<T>::ptr()) T; }
+};
+
+/**
+ * @brief Read lock object and provide read access.
+ */
+template<typename T>
+struct AIReadAccessConst
+{
+        //! Internal enum for the lock-type of the AI*Access object.
+        enum state_type
+        {
+                readlocked,                     //!< A AIReadAccessConst or AIReadAccess.
+                read2writelocked,       //!< A AIWriteAccess constructed from a AIReadAccess.
+                writelocked,            //!< A AIWriteAccess constructed from a AIThreadSafe.
+                write2writelocked       //!< A AIWriteAccess constructed from (the AIReadAccess base class of) a AIWriteAccess.
+        };
+
+        //! Construct a AIReadAccessConst from a constant AIThreadSafe.
+        AIReadAccessConst(AIThreadSafe<T> const& wrapper)
+                : mWrapper(const_cast<AIThreadSafe<T>&>(wrapper)),
+                  mState(readlocked)
+                {
+                        mWrapper.mRWLock.rdlock();
+                }
+
+        //! Destruct the AI*Access object.
+        // These should never be dynamically allocated, so there is no need to make this virtual.
+        ~AIReadAccessConst()
+                {
+                        if (mState == readlocked)
+                                mWrapper.mRWLock.rdunlock();
+                        else if (mState == writelocked)
+                                mWrapper.mRWLock.wrunlock();
+                        else if (mState == read2writelocked)
+                                mWrapper.mRWLock.wr2rdlock();
+                }
+
+        //! Access the underlaying object for read access.
+        T const* operator->() const { return mWrapper.ptr(); }
+
+        //! Access the underlaying object for read access.
+        T const& operator*() const { return *mWrapper.ptr(); }
+
+protected:
+        //! Constructor used by AIReadAccess.
+        AIReadAccessConst(AIThreadSafe<T>& wrapper, state_type state)
+                : mWrapper(wrapper), mState(state) { }
+
+        AIThreadSafe<T>& mWrapper;      //!< Reference to the object that we provide access to.
+        state_type const mState;        //!< The lock state that mWrapper is in.
+
+private:
+        // Disallow copy constructing directly.
+        AIReadAccessConst(AIReadAccessConst const&);
+};
+
+/**
+ * @brief Read lock object and provide read access, with possible promotion to write access.
+ */
+template<typename T>
+struct AIReadAccess : public AIReadAccessConst<T>
+{
+        typedef typename AIReadAccessConst<T>::state_type state_type;
+        using AIReadAccessConst<T>::readlocked;
+
+        //! Construct a AIReadAccess from a non-constant AIThreadSafe.
+        AIReadAccess(AIThreadSafe<T>& wrapper) : AIReadAccessConst<T>(wrapper, readlocked) { this->mWrapper.mRWLock.rdlock(); }
+
+protected:
+        //! Constructor used by AIWriteAccess.
+        AIReadAccess(AIThreadSafe<T>& wrapper, state_type state) : AIReadAccessConst<T>(wrapper, state) { }
+
+        friend class AIWriteAccess<T>;
+};
+
+/**
+ * @brief Write lock object and provide read/write access.
+ */
+template<typename T>
+struct AIWriteAccess : public AIReadAccess<T>
+{
+        using AIReadAccessConst<T>::readlocked;
+        using AIReadAccessConst<T>::read2writelocked;
+        using AIReadAccessConst<T>::writelocked;
+        using AIReadAccessConst<T>::write2writelocked;
+
+        //! Construct a AIWriteAccess from a non-constant AIThreadSafe.
+        AIWriteAccess(AIThreadSafe<T>& wrapper) : AIReadAccess<T>(wrapper, writelocked) { this->mWrapper.mRWLock.wrlock();}
+
+        //! Promote read access to write access.
+        explicit AIWriteAccess(AIReadAccess<T>& access)
+                : AIReadAccess<T>(access.mWrapper, (access.mState == readlocked) ? read2writelocked : write2writelocked)
+                {
+                        if (this->mState == read2writelocked)
+                        {
+                                this->mWrapper.mRWLock.rd2wrlock();
+                        }
+                }
+
+        //! Access the underlaying object for (read and) write access.
+        T* operator->() const { return this->mWrapper.ptr(); }
+
+        //! Access the underlaying object for (read and) write access.
+        T& operator*() const { return *this->mWrapper.ptr(); }
+};
+
+/**
+ * @brief A wrapper class for objects that need to be accessed by more than one thread.
+ *
+ * Use AITHREADSAFESIMPLE to define instances of any type, and use AIAccess
+ * to get access to the instance.
+ *
+ * For example,
+ *
+ * <code>
+ * class Foo { public: Foo(int, int); };
+ *
+ * AITHREADSAFESIMPLE(Foo, foo, (2, 3));
+ *
+ * AIAccess<Foo> foo_w(foo);
+ * // Use foo_w-> for read and write access.
+ *
+ * See also AIThreadSafe
+ */
+template<typename T>
+class AIThreadSafeSimple : public AIThreadSafeBits<T>
+{
+protected:
+        // Only this one may access the object (through ptr()).
+        friend struct AIAccess<T>;
+
+        // Locking control.
+        LLMutex mMutex;
+
+        // For use by AIThreadSafeSimpleDC
+        AIThreadSafeSimple(void) { }
+        AIThreadSafeSimple(AIAPRPool& parent) : mMutex(parent) { }
+
+public:
+        // Only for use by AITHREADSAFESIMPLE, see below.
+        AIThreadSafeSimple(T* object) { llassert(object == AIThreadSafeBits<T>::ptr()); }
+};
+
+/**
+ * @brief Instantiate an static, global or local object of a given type wrapped in AIThreadSafeSimple, using an arbitrary constructor.
+ *
+ * For example, instead of doing
+ *
+ * <code>
+ * Foo foo(x, y);
+ * static Bar bar;
+ * </code>
+ *
+ * One can instantiate a thread-safe instance with
+ *
+ * <code>
+ * AITHREADSAFESIMPLE(Foo, foo, (x, y));
+ * static AITHREADSAFESIMPLE(Bar, bar, );
+ * </code>
+ *
+ * Note: This macro does not allow to allocate such object on the heap.
+ *       If that is needed, have a look at AIThreadSafeSimpleDC.
+ */
+#define AITHREADSAFESIMPLE(type, var, paramlist) AIThreadSafeSimple<type> var(new (var.memory()) type paramlist)
+
+/**
+ * @brief A wrapper class for objects that need to be accessed by more than one thread.
+ *
+ * This class is the same as an AIThreadSafeSimple wrapper, except that it can only
+ * be used for default constructed objects.
+ *
+ * For example, instead of
+ *
+ * <code>
+ * Foo foo;
+ * </code>
+ *
+ * One would use
+ *
+ * <code>
+ * AIThreadSafeSimpleDC<Foo> foo;
+ * </code>
+ *
+ * The advantage over AITHREADSAFESIMPLE is that this object can be allocated with
+ * new on the heap. For example:
+ *
+ * <code>
+ * AIThreadSafeSimpleDC<Foo>* ptr = new AIThreadSafeSimpleDC<Foo>;
+ * </code>
+ *
+ * which is not possible with AITHREADSAFESIMPLE.
+ */
+template<typename T>
+class AIThreadSafeSimpleDC : public AIThreadSafeSimple<T>
+{
+public:
+        // Construct a wrapper around a default constructed object.
+        AIThreadSafeSimpleDC(void) { new (AIThreadSafeSimple<T>::ptr()) T; }
+
+protected:
+        // For use by AIThreadSafeSimpleDCRootPool
+        AIThreadSafeSimpleDC(AIAPRPool& parent) : AIThreadSafeSimple<T>(parent) { new (AIThreadSafeSimple<T>::ptr()) T; }
+};
+
+// Helper class for AIThreadSafeSimpleDCRootPool to assure initialization of
+// the root pool before constructing AIThreadSafeSimpleDC.
+class AIThreadSafeSimpleDCRootPool_pbase
+{
+protected:
+        AIAPRRootPool mRootPool;
+
+private:
+        template<typename T> friend class AIThreadSafeSimpleDCRootPool;
+        AIThreadSafeSimpleDCRootPool_pbase(void) { }
+};
+
+/**
+ * @brief A wrapper class for objects that need to be accessed by more than one thread.
+ *
+ * The same as AIThreadSafeSimpleDC except that this class creates its own AIAPRRootPool
+ * for the internally used mutexes and condition, instead of using the current threads
+ * root pool. The advantage of this is that it can be used for objects that need to
+ * be accessed from the destructors of global objects (after main). The disadvantage
+ * is that it's less efficient to use your own root pool, therefore it's use should be
+ * restricted to those cases where it is absolutely necessary.
+ */
+template<typename T>
+class AIThreadSafeSimpleDCRootPool : private AIThreadSafeSimpleDCRootPool_pbase, public AIThreadSafeSimpleDC<T>
+{
+public:
+        // Construct a wrapper around a default constructed object, using memory allocated
+        // from the operating system for the internal APR objects (mutexes and conditional),
+        // as opposed to allocated from the current threads root pool.
+        AIThreadSafeSimpleDCRootPool(void) :
+                AIThreadSafeSimpleDCRootPool_pbase(),
+                AIThreadSafeSimpleDC<T>(mRootPool) { }
+};
+
+/**
+ * @brief Write lock object and provide read/write access.
+ */
+template<typename T>
+struct AIAccess
+{
+        //! Construct a AIAccess from a non-constant AIThreadSafeSimple.
+        AIAccess(AIThreadSafeSimple<T>& wrapper) : mWrapper(wrapper) { this->mWrapper.mMutex.lock(); }
+
+        //! Access the underlaying object for (read and) write access.
+        T* operator->() const { return this->mWrapper.ptr(); }
+
+        //! Access the underlaying object for (read and) write access.
+        T& operator*() const { return *this->mWrapper.ptr(); }
+
+        ~AIAccess() { this->mWrapper.mMutex.unlock(); }
+
+protected:
+        AIThreadSafeSimple<T>& mWrapper;        //!< Reference to the object that we provide access to.
+
+private:
+        // Disallow copy constructing directly.
+        AIAccess(AIAccess const&);
+};
+
+#endif
diff --git a/linden/indra/llcommon/llapp.cpp b/linden/indra/llcommon/llapp.cpp
index e269f59..eedc503 100644
--- a/linden/indra/llcommon/llapp.cpp
+++ b/linden/indra/llcommon/llapp.cpp
@@ -119,13 +119,8 @@ void LLApp::commonCtor()
                 mOptions.append(sd);
         }
 
-        // Make sure we clean up APR when we exit
-        // Don't need to do this if we're cleaning up APR in the destructor
-        //atexit(ll_cleanup_apr);
-
         // Set the application to this instance.
         sApplication = this;
-
 }
 
 LLApp::LLApp(LLErrorThread *error_thread) :
diff --git a/linden/indra/llcommon/llapr.cpp b/linden/indra/llcommon/llapr.cpp
index 7e3a26c..a013d9c 100644
--- a/linden/indra/llcommon/llapr.cpp
+++ b/linden/indra/llcommon/llapr.cpp
@@ -34,220 +34,7 @@
 
 #include "linden_common.h"
 #include "llapr.h"
-
-apr_pool_t *gAPRPoolp = NULL; // Global APR memory pool
-apr_thread_mutex_t *gLogMutexp = NULL;
-apr_thread_mutex_t *gCallStacksLogMutexp = NULL;
-
-const S32 FULL_VOLATILE_APR_POOL = 1024 ; //number of references to LLVolatileAPRPool
-
-void ll_init_apr()
-{
-        if (!gAPRPoolp)
-        {
-                // Initialize APR and create the global pool
-                apr_initialize();
-                apr_pool_create(&gAPRPoolp, NULL);
-                
-                // Initialize the logging mutex
-                apr_thread_mutex_create(&gLogMutexp, APR_THREAD_MUTEX_UNNESTED, gAPRPoolp);
-                apr_thread_mutex_create(&gCallStacksLogMutexp, APR_THREAD_MUTEX_UNNESTED, gAPRPoolp);
-
-                // Initialize thread-local APR pool support.
-                LLVolatileAPRPool::initLocalAPRFilePool();
-        }
-}
-
-
-void ll_cleanup_apr()
-{
-        LL_INFOS("APR") << "Cleaning up APR" << LL_ENDL;
-
-        if (gLogMutexp)
-        {
-                // Clean up the logging mutex
-
-                // All other threads NEED to be done before we clean up APR, so this is okay.
-                apr_thread_mutex_destroy(gLogMutexp);
-                gLogMutexp = NULL;
-        }
-        if (gCallStacksLogMutexp)
-        {
-                // Clean up the logging mutex
-
-                // All other threads NEED to be done before we clean up APR, so this is okay.
-                apr_thread_mutex_destroy(gCallStacksLogMutexp);
-                gCallStacksLogMutexp = NULL;
-        }
-        if (gAPRPoolp)
-        {
-                apr_pool_destroy(gAPRPoolp);
-                gAPRPoolp = NULL;
-        }
-        apr_terminate();
-}
-
-//
-//
-//LLAPRPool
-//
-LLAPRPool::LLAPRPool(apr_pool_t *parent, apr_size_t size, BOOL releasePoolFlag) 
-{
-        mParent = parent ;
-        mReleasePoolFlag = releasePoolFlag ;
-        mMaxSize = size ;
-        mPool = NULL ;
-
-        createAPRPool() ;
-}
-
-LLAPRPool::~LLAPRPool() 
-{
-        releaseAPRPool() ;
-}
-
-void LLAPRPool::createAPRPool()
-{
-        if(mPool)
-        {
-                return ;
-        }
-
-        mStatus = apr_pool_create(&mPool, mParent);
-        ll_apr_warn_status(mStatus) ;
-
-        if(mMaxSize > 0) //size is the number of blocks (which is usually 4K), NOT bytes.
-        {
-                apr_allocator_t *allocator = apr_pool_allocator_get(mPool); 
-                if (allocator) 
-                { 
-                        apr_allocator_max_free_set(allocator, mMaxSize) ;
-                }
-        }
-}
-
-void LLAPRPool::releaseAPRPool()
-{
-        if(!mPool)
-        {
-                return ;
-        }
-
-        if(!mParent || mReleasePoolFlag)
-        {
-                apr_pool_destroy(mPool) ;
-                mPool = NULL ;
-        }
-}
-
-apr_pool_t* LLAPRPool::getAPRPool() 
-{
-        if(!mPool)
-        {
-                createAPRPool() ;
-        }
-        
-        return mPool ; 
-}
-LLVolatileAPRPool::LLVolatileAPRPool(apr_pool_t *parent, apr_size_t size, BOOL releasePoolFlag) 
-                                  : LLAPRPool(parent, size, releasePoolFlag)
-{
-        mNumActiveRef = 0 ;
-        mNumTotalRef = 0 ;
-}
-
-apr_pool_t* LLVolatileAPRPool::getVolatileAPRPool() 
-{
-        mNumTotalRef++ ;
-        mNumActiveRef++ ;
-        return getAPRPool() ;
-}
-
-void LLVolatileAPRPool::clearVolatileAPRPool() 
-{
-        if(mNumActiveRef > 0)
-        {
-                mNumActiveRef--;
-                if(mNumActiveRef < 1)
-                {
-                        if(isFull()) 
-                        {
-                                mNumTotalRef = 0 ;
-
-                                //destroy the apr_pool.
-                                releaseAPRPool() ;
-                        }
-                        else 
-                        {
-                                //This does not actually free the memory, 
-                                //it just allows the pool to re-use this memory for the next allocation. 
-                                apr_pool_clear(mPool) ;
-                        }
-                }
-        }
-        else
-        {
-                llassert_always(mNumActiveRef > 0) ;
-        }
-
-        //paranoia check if the pool is jammed.
-        //will remove the check before going to release.
-        llassert_always(mNumTotalRef < (FULL_VOLATILE_APR_POOL << 2)) ;
-}
-
-BOOL LLVolatileAPRPool::isFull()
-{
-        return mNumTotalRef > FULL_VOLATILE_APR_POOL ;
-}
-
-#ifdef SHOW_ASSERT
-// This allows the use of llassert(is_main_thread()) to assure the current thread is the main thread.
-static void* gIsMainThread;
-bool is_main_thread() { return gIsMainThread == LLVolatileAPRPool::getLocalAPRFilePool(); }
-#endif
-
-// The thread private handle to access the LocalAPRFilePool.
-apr_threadkey_t* LLVolatileAPRPool::sLocalAPRFilePoolKey;
-
-// This should be called exactly once, before the first call to createLocalAPRFilePool.
-// static
-void LLVolatileAPRPool::initLocalAPRFilePool()
-{
-        apr_status_t status = apr_threadkey_private_create(&sLocalAPRFilePoolKey, &destroyLocalAPRFilePool, gAPRPoolp);
-        ll_apr_assert_status(status);                   // Or out of memory, or system-imposed limit on the
-                                                        // total number of keys per process {PTHREAD_KEYS_MAX}
-                                                        // has been exceeded.
-        // Create the thread-local pool for the main thread (this function is called by the main thread).
-        createLocalAPRFilePool();
-#ifdef SHOW_ASSERT
-        gIsMainThread = getLocalAPRFilePool();
-#endif
-}
-
-// This should be called once for every thread, before it uses getLocalAPRFilePool.
-// static
-void LLVolatileAPRPool::createLocalAPRFilePool()
-{
-        void* thread_local_data = new LLVolatileAPRPool;
-        apr_status_t status = apr_threadkey_private_set(thread_local_data, sLocalAPRFilePoolKey);
-        llassert_always(status == APR_SUCCESS);
-}
-
-// This is called once for every thread when the thread is destructed.
-// static
-void LLVolatileAPRPool::destroyLocalAPRFilePool(void* thread_local_data)
-{
-        delete reinterpret_cast<LLVolatileAPRPool*>(thread_local_data);
-}
-
-// static
-LLVolatileAPRPool* LLVolatileAPRPool::getLocalAPRFilePool()
-{
-        void* thread_local_data;
-        apr_status_t status = apr_threadkey_private_get(&thread_local_data, sLocalAPRFilePoolKey);
-        llassert_always(status == APR_SUCCESS);
-        return reinterpret_cast<LLVolatileAPRPool*>(thread_local_data);
-}
+#include "llscopedvolatileaprpool.h"
 
 //---------------------------------------------------------------------
 //
@@ -310,13 +97,15 @@ void ll_apr_assert_status(apr_status_t status)
 //
 LLAPRFile::LLAPRFile()
         : mFile(NULL),
-          mCurrentFilePoolp(NULL)
+          mVolatileFilePoolp(NULL),
+          mRegularFilePoolp(NULL)
 {
 }
 
 LLAPRFile::LLAPRFile(const std::string& filename, apr_int32_t flags, access_t access_type)
         : mFile(NULL),
-          mCurrentFilePoolp(NULL)
+          mVolatileFilePoolp(NULL),
+          mRegularFilePoolp(NULL)
 {
         open(filename, flags, access_type);
 }
@@ -335,10 +124,16 @@ apr_status_t LLAPRFile::close()
                 mFile = NULL ;
         }
 
-        if(mCurrentFilePoolp)
+        if (mVolatileFilePoolp)
         {
-                mCurrentFilePoolp->clearVolatileAPRPool() ;
-                mCurrentFilePoolp = NULL ;
+                mVolatileFilePoolp->clearVolatileAPRPool() ;
+                mVolatileFilePoolp = NULL ;
+        }
+
+        if (mRegularFilePoolp)
+        {
+                delete mRegularFilePoolp;
+                mRegularFilePoolp = NULL;
         }
 
         return ret ;
@@ -347,25 +142,28 @@ apr_status_t LLAPRFile::close()
 apr_status_t LLAPRFile::open(std::string const& filename, apr_int32_t flags, access_t access_type, S32* sizep)
 {
         llassert_always(!mFile);
-        llassert_always(!mCurrentFilePoolp);
+        llassert_always(!mVolatileFilePoolp && !mRegularFilePoolp);
 
-        // Access the pool and increment it's reference count.
-        // The reference count of LLVolatileAPRPool objects will be decremented
-        // again in LLAPRFile::close by calling mCurrentFilePoolp->clearVolatileAPRPool().
-        apr_pool_t* pool;
-        if (access_type == local)
-        {
-                // Use a "volatile" thread-local pool.
-                mCurrentFilePoolp = LLVolatileAPRPool::getLocalAPRFilePool();
-                pool = mCurrentFilePoolp->getVolatileAPRPool();
-        }
-        else
+        apr_status_t status;
         {
-                llassert(is_main_thread());
-                pool = gAPRPoolp;
+                apr_pool_t* apr_file_open_pool;
+                if (access_type == local)
+                {
+                        // Use a "volatile" thread-local pool.
+                        mVolatileFilePoolp = &AIThreadLocalData::tldata().mVolatileAPRPool;
+                        // Access the pool and increment it's reference count.
+                        // The reference count of AIVolatileAPRPool objects will be decremented
+                        // again in LLAPRFile::close by calling mVolatileFilePoolp->clearVolatileAPRPool().
+                        apr_file_open_pool = mVolatileFilePoolp->getVolatileAPRPool();
+                }
+                else
+                {
+                        mRegularFilePoolp = new AIAPRPool(AIThreadLocalData::tldata().mRootPool);
+                        apr_file_open_pool = (*mRegularFilePoolp)();
+                }
+                status = apr_file_open(&mFile, filename.c_str(), flags, APR_OS_DEFAULT, apr_file_open_pool);
         }
-        apr_status_t s = apr_file_open(&mFile, filename.c_str(), flags, APR_OS_DEFAULT, pool);
-        if (s != APR_SUCCESS || !mFile)
+        if (status != APR_SUCCESS || !mFile)
         {
                 mFile = NULL ;
                 close() ;
@@ -373,7 +171,7 @@ apr_status_t LLAPRFile::open(std::string const& filename, apr_int32_t flags, acc
                 {
                         *sizep = 0;
                 }
-                return s;
+                return status;
         }
 
         if (sizep)
@@ -390,7 +188,7 @@ apr_status_t LLAPRFile::open(std::string const& filename, apr_int32_t flags, acc
                 *sizep = file_size;
         }
 
-        return s;
+        return status;
 }
 
 // File I/O
@@ -440,17 +238,6 @@ S32 LLAPRFile::seek(apr_seek_where_t where, S32 offset)
 //static components of LLAPRFile
 //
 
-// Used in the static functions below.
-class LLScopedVolatileAPRFilePool {
-private:
-        LLVolatileAPRPool* mPool;
-        apr_pool_t* apr_pool;
-public:
-        LLScopedVolatileAPRFilePool() : mPool(LLVolatileAPRPool::getLocalAPRFilePool()), apr_pool(mPool->getVolatileAPRPool()) { }
-        ~LLScopedVolatileAPRFilePool() { mPool->clearVolatileAPRPool(); }
-        operator apr_pool_t*() const { return apr_pool; }
-};
-
 //static
 S32 LLAPRFile::seek(apr_file_t* file_handle, apr_seek_where_t where, S32 offset)
 {
@@ -487,7 +274,7 @@ S32 LLAPRFile::seek(apr_file_t* file_handle, apr_seek_where_t where, S32 offset)
 S32 LLAPRFile::readEx(const std::string& filename, void *buf, S32 offset, S32 nbytes)
 {
         apr_file_t* file_handle;
-        LLScopedVolatileAPRFilePool pool;
+        LLScopedVolatileAPRPool pool;
         apr_status_t s = apr_file_open(&file_handle, filename.c_str(), APR_READ|APR_BINARY, APR_OS_DEFAULT, pool);
         if (s != APR_SUCCESS || !file_handle)
         {
@@ -539,7 +326,7 @@ S32 LLAPRFile::writeEx(const std::string& filename, void *buf, S32 offset, S32 n
         }
         
         apr_file_t* file_handle;
-        LLScopedVolatileAPRFilePool pool;
+        LLScopedVolatileAPRPool pool;
         apr_status_t s = apr_file_open(&file_handle, filename.c_str(), flags, APR_OS_DEFAULT, pool);
         if (s != APR_SUCCESS || !file_handle)
         {
@@ -584,7 +371,7 @@ bool LLAPRFile::remove(const std::string& filename)
 {
         apr_status_t s;
 
-        LLScopedVolatileAPRFilePool pool;
+        LLScopedVolatileAPRPool pool;
         s = apr_file_remove(filename.c_str(), pool);
 
         if (s != APR_SUCCESS)
@@ -601,7 +388,7 @@ bool LLAPRFile::rename(const std::string& filename, const std::string& newname)
 {
         apr_status_t s;
 
-        LLScopedVolatileAPRFilePool pool;
+        LLScopedVolatileAPRPool pool;
         s = apr_file_rename(filename.c_str(), newname.c_str(), pool);
         
         if (s != APR_SUCCESS)
@@ -619,7 +406,7 @@ bool LLAPRFile::isExist(const std::string& filename, apr_int32_t flags)
         apr_file_t* file_handle;
         apr_status_t s;
 
-        LLScopedVolatileAPRFilePool pool;
+        LLScopedVolatileAPRPool pool;
         s = apr_file_open(&file_handle, filename.c_str(), flags, APR_OS_DEFAULT, pool);
 
         if (s != APR_SUCCESS || !file_handle)
@@ -640,7 +427,7 @@ S32 LLAPRFile::size(const std::string& filename)
         apr_finfo_t info;
         apr_status_t s;
         
-        LLScopedVolatileAPRFilePool pool;
+        LLScopedVolatileAPRPool pool;
         s = apr_file_open(&file_handle, filename.c_str(), APR_READ, APR_OS_DEFAULT, pool);
         
         if (s != APR_SUCCESS || !file_handle)
@@ -669,7 +456,7 @@ bool LLAPRFile::makeDir(const std::string& dirname)
 {
         apr_status_t s;
 
-        LLScopedVolatileAPRFilePool pool;
+        LLScopedVolatileAPRPool pool;
         s = apr_dir_make(dirname.c_str(), APR_FPROT_OS_DEFAULT, pool);
                 
         if (s != APR_SUCCESS)
@@ -686,7 +473,7 @@ bool LLAPRFile::removeDir(const std::string& dirname)
 {
         apr_status_t s;
 
-        LLScopedVolatileAPRFilePool pool;
+        LLScopedVolatileAPRPool pool;
         s = apr_file_remove(dirname.c_str(), pool);
         
         if (s != APR_SUCCESS)
diff --git a/linden/indra/llcommon/llapr.h b/linden/indra/llcommon/llapr.h
index 2aed515..ded15f5 100644
--- a/linden/indra/llcommon/llapr.h
+++ b/linden/indra/llcommon/llapr.h
@@ -48,73 +48,8 @@
 #include "apr_atomic.h"
 #include "llstring.h"
 
-extern LL_COMMON_API apr_thread_mutex_t* gLogMutexp;
-
-/** 
- * @brief initialize the common apr constructs -- apr itself, the
- * global pool, and a mutex.
- */
-void LL_COMMON_API ll_init_apr();
-
-/** 
- * @brief Cleanup those common apr constructs.
- */
-void LL_COMMON_API ll_cleanup_apr();
-
-//
-//LL apr_pool
-//manage apr_pool_t, destroy allocated apr_pool in the destruction function.
-//
-class LL_COMMON_API LLAPRPool
-{
-public:
-        LLAPRPool(apr_pool_t *parent = NULL, apr_size_t size = 0, BOOL releasePoolFlag = TRUE) ;
-        ~LLAPRPool() ;
-
-        apr_pool_t* getAPRPool() ;
-        apr_status_t getStatus() {return mStatus ; }
-
-protected:
-        void releaseAPRPool() ;
-        void createAPRPool() ;
-
-protected:
-        apr_pool_t*  mPool ;              //pointing to an apr_pool
-        apr_pool_t*  mParent ;                    //parent pool
-        apr_size_t   mMaxSize ;           //max size of mPool, mPool should return memory to system if allocated memory beyond this limit. However it seems not to work.
-        apr_status_t mStatus ;            //status when creating the pool
-        BOOL         mReleasePoolFlag ;   //if set, mPool is destroyed when LLAPRPool is deleted. default value is true.
-};
-
-//
-//volatile LL apr_pool
-//which clears memory automatically.
-//so it can not hold static data or data after memory is cleared
-//
-class LL_COMMON_API LLVolatileAPRPool : protected LLAPRPool
-{
-public:
-        LLVolatileAPRPool(apr_pool_t *parent = NULL, apr_size_t size = 0, BOOL releasePoolFlag = TRUE);
-        ~LLVolatileAPRPool(){}
-
-        apr_pool_t* getVolatileAPRPool() ;
-        
-        void        clearVolatileAPRPool() ;
-
-        BOOL        isFull() ;
-        BOOL        isEmpty() {return !mNumActiveRef ;}
-
-        static void initLocalAPRFilePool();
-        static void createLocalAPRFilePool();
-        static void destroyLocalAPRFilePool(void* thread_local_data);
-        static LLVolatileAPRPool* getLocalAPRFilePool();
-
-private:
-        S32 mNumActiveRef ; //number of active pointers pointing to the apr_pool.
-        S32 mNumTotalRef ;  //number of total pointers pointing to the apr_pool since last creating.   
-
-        static apr_threadkey_t*         sLocalAPRFilePoolKey;
-} ;
+class AIAPRPool;
+class AIVolatileAPRPool;
 
 /** 
  * @class LLScopedLock
@@ -205,7 +140,8 @@ class LL_COMMON_API LLAPRFile : boost::noncopyable
         // make this non copyable since a copy closes the file
 private:
         apr_file_t* mFile ;
-        LLVolatileAPRPool *mCurrentFilePoolp ; //currently in use apr_pool, could be one of them: sAPRFilePoolp, or a temp pool. 
+        AIVolatileAPRPool* mVolatileFilePoolp;  // (Thread local) APR pool currently in use.
+        AIAPRPool* mRegularFilePoolp;           // ...or a regular pool.
 
 public:
         enum access_t {
@@ -260,6 +196,4 @@ bool LL_COMMON_API ll_apr_warn_status(apr_status_t status);
 
 void LL_COMMON_API ll_apr_assert_status(apr_status_t status);
 
-extern "C" LL_COMMON_API apr_pool_t* gAPRPoolp; // Global APR memory pool
-
 #endif // LL_LLAPR_H
diff --git a/linden/indra/llcommon/llavatarname.cpp b/linden/indra/llcommon/llavatarname.cpp
new file mode 100644
index 0000000..ebe8c88
--- /dev/null
+++ b/linden/indra/llcommon/llavatarname.cpp
@@ -0,0 +1,150 @@
+/** 
+ * @file llavatarname.cpp
+ * @brief Represents name-related data for an avatar, such as the
+ * username/SLID ("bobsmith123" or "james.linden") and the display
+ * name ("James Cook")
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+#include "linden_common.h"
+
+#include "llavatarname.h"
+
+#include "lldate.h"
+#include "llsd.h"
+
+bool LLAvatarName::sOmitResidentAsLastName = false;
+
+// Store these in pre-built std::strings to avoid memory allocations in
+// LLSD map lookups
+static const std::string USERNAME("username");
+static const std::string DISPLAY_NAME("display_name");
+static const std::string LEGACY_FIRST_NAME("legacy_first_name");
+static const std::string LEGACY_LAST_NAME("legacy_last_name");
+static const std::string IS_DISPLAY_NAME_DEFAULT("is_display_name_default");
+static const std::string DISPLAY_NAME_EXPIRES("display_name_expires");
+static const std::string DISPLAY_NAME_NEXT_UPDATE("display_name_next_update");
+
+LLAvatarName::LLAvatarName()
+:       mUsername(),
+        mDisplayName(),
+        mLegacyFirstName(),
+        mLegacyLastName(),
+        mIsDisplayNameDefault(false),
+        mIsDummy(false),
+        mExpires(F64_MAX),
+        mNextUpdate(0.0)
+{ }
+
+bool LLAvatarName::operator<(const LLAvatarName& rhs) const
+{
+        if (mUsername == rhs.mUsername)
+                return mDisplayName < rhs.mDisplayName;
+        else
+                return mUsername < rhs.mUsername;
+}
+
+LLSD LLAvatarName::asLLSD() const
+{
+        LLSD sd;
+        sd[USERNAME] = mUsername;
+        sd[DISPLAY_NAME] = mDisplayName;
+        sd[LEGACY_FIRST_NAME] = mLegacyFirstName;
+        sd[LEGACY_LAST_NAME] = mLegacyLastName;
+        sd[IS_DISPLAY_NAME_DEFAULT] = mIsDisplayNameDefault;
+        sd[DISPLAY_NAME_EXPIRES] = LLDate(mExpires);
+        sd[DISPLAY_NAME_NEXT_UPDATE] = LLDate(mNextUpdate);
+        return sd;
+}
+
+void LLAvatarName::fromLLSD(const LLSD& sd)
+{
+        mUsername = sd[USERNAME].asString();
+        mDisplayName = sd[DISPLAY_NAME].asString();
+        mLegacyFirstName = sd[LEGACY_FIRST_NAME].asString();
+        mLegacyLastName = sd[LEGACY_LAST_NAME].asString();
+        mIsDisplayNameDefault = sd[IS_DISPLAY_NAME_DEFAULT].asBoolean();
+        LLDate expires = sd[DISPLAY_NAME_EXPIRES];
+        mExpires = expires.secondsSinceEpoch();
+        LLDate next_update = sd[DISPLAY_NAME_NEXT_UPDATE];
+        mNextUpdate = next_update.secondsSinceEpoch();
+}
+
+std::string LLAvatarName::getCompleteName() const
+{
+        std::string name;
+        if (!mUsername.empty())
+        {
+                name = mDisplayName + " (" + mUsername + ")";
+        }
+        else
+        {
+                // ...display names are off, legacy name is in mDisplayName
+                name = mDisplayName;
+        }
+        return name;
+}
+
+std::string LLAvatarName::getLegacyName() const
+{
+        std::string name;
+        name.reserve(mLegacyFirstName.size() + 1 + mLegacyLastName.size());
+        name = mLegacyFirstName;
+        if (!sOmitResidentAsLastName || mLegacyLastName != "Resident")
+        {
+                name += " ";
+                name += mLegacyLastName;
+        }
+        return name;
+}
+
+std::string LLAvatarName::getNames(bool linefeed) const
+{
+        std::string name;
+
+        if (mUsername.empty())
+        {
+                // ...display names are off, legacy name is in mDisplayName
+                name = mDisplayName;
+                if (sOmitResidentAsLastName)
+                {
+                        LLStringUtil::replaceString(name, " Resident", "");
+                }
+        }
+        else
+        {
+                name = getLegacyName();
+                if (name != mDisplayName)
+                {
+                        if (linefeed)
+                        {
+                                name = mDisplayName + "\n[" + name + "]";
+                        }
+                        else
+                        {
+                                name = mDisplayName + " [" + name + "]";
+                        }
+                }
+        }
+
+        return name;
+}
diff --git a/linden/indra/llcommon/llavatarname.h b/linden/indra/llcommon/llavatarname.h
new file mode 100644
index 0000000..3b6c6ea
--- /dev/null
+++ b/linden/indra/llcommon/llavatarname.h
@@ -0,0 +1,105 @@
+/** 
+ * @file llavatarname.h
+ * @brief Represents name-related data for an avatar, such as the
+ * username/SLID ("bobsmith123" or "james.linden") and the display
+ * name ("James Cook")
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+#ifndef LLAVATARNAME_H
+#define LLAVATARNAME_H
+
+#include <string>
+
+class LLSD;
+
+class LL_COMMON_API LLAvatarName
+{
+public:
+        LLAvatarName();
+        
+        bool operator<(const LLAvatarName& rhs) const;
+
+        LLSD asLLSD() const;
+
+        void fromLLSD(const LLSD& sd);
+
+        // For normal names, returns "James Linden (james.linden)"
+        // When display names are disabled returns just "James Linden"
+        std::string getCompleteName() const;
+
+        // For normal names, returns "Whatever Display Name (John Doe)" when
+        // display name and legacy name are different, or just "John Doe"
+        // when they are equal or when display names are disabled.
+        // When linefeed == true, the space between the display name and
+        // the opening parenthesis for the legacy name is replaced with a
+        // line feed.
+        std::string getNames(bool linefeed = false) const;
+
+        // Returns "James Linden" or "bobsmith123 Resident" for backwards
+        // compatibility with systems like voice and muting
+        std::string getLegacyName() const;
+
+        // "bobsmith123" or "james.linden", US-ASCII only
+        std::string mUsername;
+
+        // "Jose' Sanchez" or "James Linden", UTF-8 encoded Unicode
+        // Contains data whether or not user has explicitly set
+        // a display name; may duplicate their username.
+        std::string mDisplayName;
+
+        // For "James Linden", "James"
+        // For "bobsmith123", "bobsmith123"
+        // Used to communicate with legacy systems like voice and muting which
+        // rely on old-style names.
+        std::string mLegacyFirstName;
+
+        // For "James Linden", "Linden"
+        // For "bobsmith123", "Resident"
+        // see above for rationale
+        std::string mLegacyLastName;
+
+        // If true, both display name and SLID were generated from
+        // a legacy first and last name, like "James Linden (james.linden)"
+        bool mIsDisplayNameDefault;
+
+        // Under error conditions, we may insert "dummy" records with
+        // names equal to legacy name into caches as placeholders.
+        // These can be shown in UI, but are not serialized.
+        bool mIsDummy;
+
+        // Names can change, so need to keep track of when name was
+        // last checked.
+        // Unix time-from-epoch seconds for efficiency
+        F64 mExpires;
+        
+        // You can only change your name every N hours, so record
+        // when the next update is allowed
+        // Unix time-from-epoch seconds
+        F64 mNextUpdate;
+
+        // true to prevent the displaying of "Resident" as a last name
+        // in legacy names
+        static bool sOmitResidentAsLastName;
+};
+
+#endif
diff --git a/linden/indra/llcommon/llcommon.cpp b/linden/indra/llcommon/llcommon.cpp
index 2cbb718..298dd46 100644
--- a/linden/indra/llcommon/llcommon.cpp
+++ b/linden/indra/llcommon/llcommon.cpp
@@ -35,17 +35,9 @@
 #include "llthread.h"
 
 //static
-BOOL LLCommon::sAprInitialized = FALSE;
-
-//static
 void LLCommon::initClass()
 {
         LLMemory::initClass();
-        if (!sAprInitialized)
-        {
-                ll_init_apr();
-                sAprInitialized = TRUE;
-        }
         LLTimer::initClass();
         LLThreadSafeRefCount::initThreadSafeRefCount();
 //      LLWorkerThread::initClass();
@@ -59,10 +51,5 @@ void LLCommon::cleanupClass()
 //      LLWorkerThread::cleanupClass();
         LLThreadSafeRefCount::cleanupThreadSafeRefCount();
         LLTimer::cleanupClass();
-        if (sAprInitialized)
-        {
-                ll_cleanup_apr();
-                sAprInitialized = FALSE;
-        }
         LLMemory::cleanupClass();
 }
diff --git a/linden/indra/llcommon/llcommon.h b/linden/indra/llcommon/llcommon.h
index 851d4ac..300ebe2 100644
--- a/linden/indra/llcommon/llcommon.h
+++ b/linden/indra/llcommon/llcommon.h
@@ -43,8 +43,6 @@ class LL_COMMON_API LLCommon
 public:
         static void initClass();
         static void cleanupClass();
-private:
-        static BOOL sAprInitialized;
 };
 
 #endif
diff --git a/linden/indra/llcommon/llerror.cpp b/linden/indra/llcommon/llerror.cpp
index edc570f..a9587c6 100644
--- a/linden/indra/llcommon/llerror.cpp
+++ b/linden/indra/llcommon/llerror.cpp
@@ -46,6 +46,8 @@
 # include <unistd.h>
 #endif // !LL_WINDOWS
 #if LL_WINDOWS
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
 # include <windows.h>
 #endif // LL_WINDOWS
 #include <vector>
@@ -871,6 +873,9 @@ You get:
         
 */
 
+apr_thread_mutex_t* gLogMutexp;
+apr_thread_mutex_t* gCallStacksLogMutexp;
+
 namespace {
         bool checkLevelMap(const LevelMap& map, const std::string& key,
                                                 LLError::ELevel& level)
diff --git a/linden/indra/llcommon/llfile.cpp b/linden/indra/llcommon/llfile.cpp
index 2a76f7f..6b68630 100644
--- a/linden/indra/llcommon/llfile.cpp
+++ b/linden/indra/llcommon/llfile.cpp
@@ -34,6 +34,8 @@
  */
 
 #if LL_WINDOWS
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
 #include <windows.h>
 #endif
 
diff --git a/linden/indra/llcommon/llfindlocale.cpp b/linden/indra/llcommon/llfindlocale.cpp
index 505f5c5..71675af 100644
--- a/linden/indra/llcommon/llfindlocale.cpp
+++ b/linden/indra/llcommon/llfindlocale.cpp
@@ -39,6 +39,8 @@
 #include <ctype.h>
 
 #ifdef WIN32
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
 #include <windows.h>
 #include <winnt.h>
 #endif
diff --git a/linden/indra/llcommon/llfixedbuffer.cpp b/linden/indra/llcommon/llfixedbuffer.cpp
index e9d6029..37a12ad 100644
--- a/linden/indra/llcommon/llfixedbuffer.cpp
+++ b/linden/indra/llcommon/llfixedbuffer.cpp
@@ -33,9 +33,8 @@
 #include "llfixedbuffer.h"
 
 LLFixedBuffer::LLFixedBuffer(const U32 max_lines)
-                          : mMutex(NULL)
+        : mMaxLines(max_lines)
 {
-        mMaxLines = max_lines;
         mTimer.reset();
 }
 
diff --git a/linden/indra/llcommon/llmemory.cpp b/linden/indra/llcommon/llmemory.cpp
index 74004b0..2b01442 100644
--- a/linden/indra/llcommon/llmemory.cpp
+++ b/linden/indra/llcommon/llmemory.cpp
@@ -33,6 +33,8 @@
 #include "linden_common.h"
 
 #if defined(LL_WINDOWS)
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
 # include <windows.h>
 # include <psapi.h>
 #elif defined(LL_DARWIN)
diff --git a/linden/indra/llcommon/llprocesslauncher.h b/linden/indra/llcommon/llprocesslauncher.h
index b72be27..9833a13 100644
--- a/linden/indra/llcommon/llprocesslauncher.h
+++ b/linden/indra/llcommon/llprocesslauncher.h
@@ -34,6 +34,8 @@
 #define LL_LLPROCESSLAUNCHER_H
 
 #if LL_WINDOWS
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
 #include <windows.h>
 #endif
 
diff --git a/linden/indra/llcommon/llscopedvolatileaprpool.h b/linden/indra/llcommon/llscopedvolatileaprpool.h
new file mode 100644
index 0000000..724dc7f
--- /dev/null
+++ b/linden/indra/llcommon/llscopedvolatileaprpool.h
@@ -0,0 +1,58 @@
+/**
+ * @file llscopedvolatileaprpool.h
+ * @brief Implementation of LLScopedVolatileAPRPool
+ *
+ * $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://secondlifegrid.net/programs/open_source/licensing/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://secondlifegrid.net/programs/open_source/licensing/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$
+ */
+
+#ifndef LL_LLSCOPEDVOLATILEAPRPOOL_H
+#define LL_LLSCOPEDVOLATILEAPRPOOL_H
+
+#include "llthread.h"
+
+//! Scoped volatile memory pool.
+//
+// As the AIVolatileAPRPool should never keep allocations very
+// long, it's most common use is for allocations with a lifetime
+// equal to it's scope.
+//
+// This is a convenience class that makes just a little easier to type.
+//
+class LLScopedVolatileAPRPool
+{
+private:
+        AIVolatileAPRPool& mPool;
+        apr_pool_t* mScopedAPRpool;
+public:
+        LLScopedVolatileAPRPool() : mPool(AIThreadLocalData::tldata().mVolatileAPRPool), mScopedAPRpool(mPool.getVolatileAPRPool()) { }
+        ~LLScopedVolatileAPRPool() { mPool.clearVolatileAPRPool(); }
+        // Only use this to pass the pointer to a libapr-1 function that requires it.
+        operator apr_pool_t*() const { return mScopedAPRpool; }
+};
+
+#endif
diff --git a/linden/indra/llcommon/llthread.cpp b/linden/indra/llcommon/llthread.cpp
index 692d6c4..f7732cb 100644
--- a/linden/indra/llcommon/llthread.cpp
+++ b/linden/indra/llcommon/llthread.cpp
@@ -72,8 +72,8 @@ void *APR_THREAD_FUNC LLThread::staticRun(apr_thread_t *apr_threadp, void *datap
         // Set thread state to running
         threadp->mStatus = RUNNING;
 
-        // Create a thread local APRFile pool.
-        LLVolatileAPRPool::createLocalAPRFilePool();
+        // Create a thread local data.
+        AIThreadLocalData::create(threadp);
 
         // Run the user supplied function
         threadp->run();
@@ -87,24 +87,14 @@ void *APR_THREAD_FUNC LLThread::staticRun(apr_thread_t *apr_threadp, void *datap
 }
 
 
-LLThread::LLThread(const std::string& name, apr_pool_t *poolp) :
+LLThread::LLThread(std::string const& name) :
         mPaused(false),
         mName(name),
         mAPRThreadp(NULL),
-        mStatus(STOPPED)
+        mStatus(STOPPED),
+        mThreadLocalData(NULL)
 {
-        // Thread creation probably CAN be paranoid about APR being initialized, if necessary
-        if (poolp)
-        {
-                mIsLocalPool = false;
-                mAPRPoolp = poolp;
-        }
-        else
-        {
-                mIsLocalPool = true;
-                apr_pool_create(&mAPRPoolp, NULL); // Create a subpool for this thread
-        }
-        mRunCondition = new LLCondition(mAPRPoolp);
+        mRunCondition = new LLCondition;
 }
 
 
@@ -147,24 +137,18 @@ void LLThread::shutdown()
                 if (!isStopped())
                 {
                         // This thread just wouldn't stop, even though we gave it time
-                        llwarns << "LLThread::~LLThread() exiting thread before clean exit!" << llendl;
+                        llwarns << "LLThread::shutdown() exiting thread before clean exit!" << llendl;
                         return;
                 }
                 mAPRThreadp = NULL;
         }
 
         delete mRunCondition;
-        
-        if (mIsLocalPool)
-        {
-                apr_pool_destroy(mAPRPoolp);
-        }
 }
 
-
 void LLThread::start()
 {
-        apr_thread_create(&mAPRThreadp, NULL, staticRun, (void *)this, mAPRPoolp);      
+        apr_thread_create(&mAPRThreadp, NULL, staticRun, (void *)this, tldata().mRootPool());
 
         // We won't bother joining
         apr_thread_detach(mAPRThreadp);
@@ -265,38 +249,72 @@ void LLThread::wakeLocked()
         }
 }
 
-//============================================================================
+#ifdef SHOW_ASSERT
+// This allows the use of llassert(is_main_thread()) to assure the current thread is the main thread.
+static apr_os_thread_t main_thread_id;
+bool is_main_thread() { return apr_os_thread_equal(main_thread_id, apr_os_thread_current()); }
+#endif
 
-LLMutex::LLMutex(apr_pool_t *poolp) :
-        mAPRMutexp(NULL)
+// The thread private handle to access the AIThreadLocalData instance.
+apr_threadkey_t* AIThreadLocalData::sThreadLocalDataKey;
+
+//static
+void AIThreadLocalData::init(void)
 {
-        //if (poolp)
-        //{
-        //      mIsLocalPool = false;
-        //      mAPRPoolp = poolp;
-        //}
-        //else
+        // Only do this once.
+        if (sThreadLocalDataKey)
         {
-                mIsLocalPool = true;
-                apr_pool_create(&mAPRPoolp, NULL); // Create a subpool for this thread
+                return;
         }
-        apr_thread_mutex_create(&mAPRMutexp, APR_THREAD_MUTEX_UNNESTED, mAPRPoolp);
+
+        apr_status_t status = apr_threadkey_private_create(&sThreadLocalDataKey, &AIThreadLocalData::destroy, AIAPRRootPool::get()());
+        ll_apr_assert_status(status);   // Or out of memory, or system-imposed limit on the
+                                                                        // total number of keys per process {PTHREAD_KEYS_MAX}
+                                                                        // has been exceeded.
+
+        // Create the thread-local data for the main thread (this function is called by the main thread).
+        AIThreadLocalData::create(NULL);
+
+#ifdef SHOW_ASSERT
+        // This function is called by the main thread.
+        main_thread_id = apr_os_thread_current();
+#endif
 }
 
-LLMutex::~LLMutex()
+// This is called once for every thread when the thread is destructed.
+//static
+void AIThreadLocalData::destroy(void* thread_local_data)
 {
-#if _DEBUG
-        llassert(!isLocked()); // better not be locked!
-#endif
-        apr_thread_mutex_destroy(mAPRMutexp);
-        mAPRMutexp = NULL;
-        if (mIsLocalPool)
+        delete reinterpret_cast<AIThreadLocalData*>(thread_local_data);
+}
+
+//static
+void AIThreadLocalData::create(LLThread* threadp)
+{
+        AIThreadLocalData* new_tld = new AIThreadLocalData;
+        if (threadp)
         {
-                apr_pool_destroy(mAPRPoolp);
+                threadp->mThreadLocalData = new_tld;
         }
+        apr_status_t status = apr_threadkey_private_set(new_tld, sThreadLocalDataKey);
+        llassert_always(status == APR_SUCCESS);
 }
 
-bool LLMutex::isLocked()
+//static
+AIThreadLocalData& AIThreadLocalData::tldata(void)
+{
+        if (!sThreadLocalDataKey)
+                AIThreadLocalData::init();
+
+        void* data;
+        apr_status_t status = apr_threadkey_private_get(&data, sThreadLocalDataKey);
+        llassert_always(status == APR_SUCCESS);
+        return *static_cast<AIThreadLocalData*>(data);
+}
+
+//============================================================================
+
+bool LLMutexBase::isLocked()
 {
         if (!tryLock())
         {
@@ -308,12 +326,9 @@ bool LLMutex::isLocked()
 
 //============================================================================
 
-LLCondition::LLCondition(apr_pool_t *poolp) :
-        LLMutex(poolp)
+LLCondition::LLCondition(AIAPRPool& parent) : LLMutex(parent)
 {
-        // base class (LLMutex) has already ensured that mAPRPoolp is set up.
-
-        apr_thread_cond_create(&mAPRCondp, mAPRPoolp);
+        apr_thread_cond_create(&mAPRCondp, mPool());
 }
 
 LLCondition::~LLCondition()
@@ -349,7 +364,7 @@ void LLThreadSafeRefCount::initThreadSafeRefCount()
 {
         if (!sMutex)
         {
-                sMutex = new LLMutex(0);
+                sMutex = new LLMutex;
         }
 }
 
diff --git a/linden/indra/llcommon/llthread.h b/linden/indra/llcommon/llthread.h
index 98d64ef..1e982cc 100644
--- a/linden/indra/llcommon/llthread.h
+++ b/linden/indra/llcommon/llthread.h
@@ -38,11 +38,28 @@
 #include "llmemory.h"
 
 #include "apr_thread_cond.h"
+#include "aiaprpool.h"
 
 class LLThread;
 class LLMutex;
 class LLCondition;
 
+class LL_COMMON_API AIThreadLocalData
+{
+private:
+        static apr_threadkey_t* sThreadLocalDataKey;
+
+public:
+        // Thread-local memory pool.
+        AIAPRRootPool mRootPool;
+        AIVolatileAPRPool mVolatileAPRPool;
+
+        static void init(void);
+        static void destroy(void* thread_local_data);
+        static void create(LLThread* pthread);
+        static AIThreadLocalData& tldata(void);
+};
+
 class LL_COMMON_API LLThread
 {
 public:
@@ -53,7 +70,7 @@ public:
                 QUITTING= 2     // Someone wants this thread to quit
         } EThreadStatus;
 
-        LLThread(const std::string& name, apr_pool_t *poolp = NULL);
+        LLThread(std::string const& name);
         virtual ~LLThread(); // Warning!  You almost NEVER want to destroy a thread unless it's in the STOPPED state.
         virtual void shutdown(); // stops the thread
         
@@ -82,7 +99,8 @@ public:
         // this kicks off the apr thread
         void start(void);
 
-        apr_pool_t *getAPRPool() { return mAPRPoolp; }
+        // Return thread-local data for the current thread.
+        static AIThreadLocalData& tldata(void) { return AIThreadLocalData::tldata(); }
 
 private:
         bool                            mPaused;
@@ -95,10 +113,11 @@ protected:
         LLCondition*            mRunCondition;
 
         apr_thread_t            *mAPRThreadp;
-        apr_pool_t                      *mAPRPoolp;
-        bool                            mIsLocalPool;
         EThreadStatus           mStatus;
 
+        friend void AIThreadLocalData::create(LLThread* threadp);
+        AIThreadLocalData*      mThreadLocalData;
+
         void setQuitting();
         
         // virtual function overridden by subclass -- this will be called when the thread runs
@@ -125,12 +144,9 @@ protected:
 
 //============================================================================
 
-class LL_COMMON_API LLMutex
+class LL_COMMON_API LLMutexBase
 {
 public:
-        LLMutex(apr_pool_t *apr_poolp); // NULL pool constructs a new pool for the mutex
-        ~LLMutex();
-        
         void lock() { apr_thread_mutex_lock(mAPRMutexp); }
         void unlock() { apr_thread_mutex_unlock(mAPRMutexp); }
         // Returns true if lock was obtained successfully.
@@ -139,16 +155,60 @@ public:
         bool isLocked();        // non-blocking, but does do a lock/unlock so not free
 
 protected:
-        apr_thread_mutex_t *mAPRMutexp;
-        apr_pool_t                      *mAPRPoolp;
-        bool                            mIsLocalPool;
+        // mAPRMutexp is initialized and uninitialized in the derived class.
+        apr_thread_mutex_t*     mAPRMutexp;
+};
+
+class LL_COMMON_API LLMutex : public LLMutexBase
+{
+public:
+        LLMutex(AIAPRPool& parent = LLThread::tldata().mRootPool) : mPool(parent)
+        {
+                apr_thread_mutex_create(&mAPRMutexp, APR_THREAD_MUTEX_UNNESTED, mPool());
+        }
+        ~LLMutex()
+        {
+                llassert(!isLocked()); // better not be locked!
+                apr_thread_mutex_destroy(mAPRMutexp);
+                mAPRMutexp = NULL;
+        }
+
+protected:
+        AIAPRPool mPool;
 };
 
+#if APR_HAS_THREADS
+// No need to use a root pool in this case.
+typedef LLMutex LLMutexRootPool;
+#else   // APR_HAS_THREADS
+class LL_COMMON_API LLMutexRootPool : public LLMutexBase
+{
+public:
+        LLMutexRootPool(void)
+        {
+                apr_thread_mutex_create(&mAPRMutexp, APR_THREAD_MUTEX_UNNESTED, mRootPool());
+        }
+        ~LLMutexRootPool()
+        {
+#if APR_POOL_DEBUG
+                // It is allowed to destruct root pools from a different thread.
+                mRootPool.grab_ownership();
+#endif
+                llassert(!isLocked()); // better not be locked!
+                apr_thread_mutex_destroy(mAPRMutexp);
+                mAPRMutexp = NULL;
+        }
+
+protected:
+        AIAPRRootPool mRootPool;
+};
+#endif  // APR_HAS_THREADS
+
 // Actually a condition/mutex pair (since each condition needs to be associated with a mutex).
 class LL_COMMON_API LLCondition : public LLMutex
 {
 public:
-        LLCondition(apr_pool_t *apr_poolp); // Defaults to global pool, could use the thread pool as well.
+        LLCondition(AIAPRPool& parent = LLThread::tldata().mRootPool);
         ~LLCondition();
         
         void wait();            // blocks
@@ -162,7 +222,7 @@ protected:
 class LL_COMMON_API LLMutexLock
 {
 public:
-        LLMutexLock(LLMutex* mutex)
+        LLMutexLock(LLMutexBase* mutex)
         {
                 mMutex = mutex;
                 mMutex->lock();
@@ -172,7 +232,102 @@ public:
                 mMutex->unlock();
         }
 private:
-        LLMutex* mMutex;
+        LLMutexBase* mMutex;
+};
+
+class AIRWLock
+{
+public:
+        AIRWLock(AIAPRPool& parent = LLThread::tldata().mRootPool) :
+                mWriterWaitingMutex(parent), mNoHoldersCondition(parent), mHoldersCount(0), mWriterIsWaiting(false) { }
+
+private:
+        LLMutex mWriterWaitingMutex;            //!< This mutex is locked while some writer is waiting for access.
+        LLCondition mNoHoldersCondition;        //!< Access control for mHoldersCount. Condition true when there are no more holders.
+        int mHoldersCount;                                      //!< Number of readers or -1 if a writer locked this object.
+        // This is volatile because we read it outside the critical area of mWriterWaitingMutex, at [1].
+        // That means that other threads can change it while we are already in the (inlined) function rdlock.
+        // Without volatile, the following assembly would fail:
+        // register x = mWriterIsWaiting;
+        // /* some thread changes mWriterIsWaiting */
+        // if (x ...
+        // However, because the function is fuzzy to begin with (we don't mind that this race
+        // condition exists) it would work fine without volatile. So, basically it's just here
+        // out of principle ;). -- Aleric
+    bool volatile mWriterIsWaiting;             //!< True when there is a writer waiting for write access.
+
+public:
+        void rdlock(bool high_priority = false)
+        {
+                // Give a writer a higher priority (kinda fuzzy).
+                if (mWriterIsWaiting && !high_priority) // [1] If there is a writer interested,
+                {
+                        mWriterWaitingMutex.lock();                     // [2] then give it precedence and wait here.
+                        // If we get here then the writer got it's access; mHoldersCount == -1.
+                        mWriterWaitingMutex.unlock();
+                }
+                mNoHoldersCondition.lock();                             // [3] Get exclusive access to mHoldersCount.
+                while (mHoldersCount == -1)                             // [4]
+                {
+                        mNoHoldersCondition.wait();                     // [5] Wait till mHoldersCount is (or just was) 0.
+                }
+                ++mHoldersCount;                                                // One more reader.
+                mNoHoldersCondition.unlock();                   // Release lock on mHoldersCount.
+        }
+        void rdunlock(void)
+        {
+                mNoHoldersCondition.lock();                             // Get exclusive access to mHoldersCount.
+                if (--mHoldersCount == 0)                               // Was this the last reader?
+                {
+                        mNoHoldersCondition.signal();           // Tell waiting threads, see [5], [6] and [7].
+                }
+                mNoHoldersCondition.unlock();                   // Release lock on mHoldersCount.
+        }
+        void wrlock(void)
+        {
+                mWriterWaitingMutex.lock();                             // Block new readers, see [2],
+                mWriterIsWaiting = true;                                // from this moment on, see [1].
+                mNoHoldersCondition.lock();                             // Get exclusive access to mHoldersCount.
+                while (mHoldersCount != 0)                              // Other readers or writers have this lock?
+                {
+                        mNoHoldersCondition.wait();                     // [6] Wait till mHoldersCount is (or just was) 0.
+                }
+                mWriterIsWaiting = false;                               // Stop checking the lock for new readers, see [1].
+                mWriterWaitingMutex.unlock();                   // Release blocked readers, they will still hang at [3].
+                mHoldersCount = -1;                                             // We are a writer now (will cause a hang at [5], see [4]).
+                mNoHoldersCondition.unlock();                   // Release lock on mHolders (readers go from [3] to [5]).
+        }
+        void wrunlock(void)
+        {
+                mNoHoldersCondition.lock();                             // Get exclusive access to mHoldersCount.
+                mHoldersCount = 0;                                              // We have no writer anymore.
+                mNoHoldersCondition.signal();                   // Tell waiting threads, see [5], [6] and [7].
+                mNoHoldersCondition.unlock();                   // Release lock on mHoldersCount.
+        }
+        void rd2wrlock(void)
+        {
+                mNoHoldersCondition.lock();                             // Get exclusive access to mHoldersCount. Blocks new readers at [3].
+                if (--mHoldersCount > 0)                                // Any other reads left?
+                {
+                        mWriterWaitingMutex.lock();                     // Block new readers, see [2],
+                        mWriterIsWaiting = true;                        // from this moment on, see [1].
+                        while (mHoldersCount != 0)                      // Other readers (still) have this lock?
+                        {
+                                mNoHoldersCondition.wait();             // [7] Wait till mHoldersCount is (or just was) 0.
+                        }
+                        mWriterIsWaiting = false;                       // Stop checking the lock for new readers, see [1].
+                        mWriterWaitingMutex.unlock();           // Release blocked readers, they will still hang at [3].
+                }
+                mHoldersCount = -1;                                             // We are a writer now (will cause a hang at [5], see [4]).
+                mNoHoldersCondition.unlock();                   // Release lock on mHolders (readers go from [3] to [5]).
+        }
+        void wr2rdlock(void)
+        {
+                mNoHoldersCondition.lock();                             // Get exclusive access to mHoldersCount.
+                mHoldersCount = 1;                                              // Turn writer into a reader.
+                mNoHoldersCondition.signal();                   // Tell waiting readers, see [5].
+                mNoHoldersCondition.unlock();                   // Release lock on mHoldersCount.
+        }
 };
 
 //============================================================================
@@ -187,7 +342,6 @@ void LLThread::unlockData()
         mRunCondition->unlock();
 }
 
-
 //============================================================================
 
 // see llmemory.h for LLPointer<> definition
diff --git a/linden/indra/llcommon/llworkerthread.cpp b/linden/indra/llcommon/llworkerthread.cpp
index 8195e1c..e238a89 100644
--- a/linden/indra/llcommon/llworkerthread.cpp
+++ b/linden/indra/llcommon/llworkerthread.cpp
@@ -43,7 +43,7 @@
 LLWorkerThread::LLWorkerThread(const std::string& name, bool threaded) :
         LLQueuedThread(name, threaded)
 {
-        mDeleteMutex = new LLMutex(NULL);
+        mDeleteMutex = new LLMutex;
 }
 
 LLWorkerThread::~LLWorkerThread()
@@ -183,7 +183,6 @@ LLWorkerClass::LLWorkerClass(LLWorkerThread* workerthread, const std::string& na
         : mWorkerThread(workerthread),
           mWorkerClassName(name),
           mRequestHandle(LLWorkerThread::nullHandle()),
-          mMutex(NULL),
           mWorkFlags(0)
 {
         if (!mWorkerThread)
diff --git a/linden/indra/llcommon/llworkerthread.h b/linden/indra/llcommon/llworkerthread.h
index 33d4c40..8e0dd8a 100644
--- a/linden/indra/llcommon/llworkerthread.h
+++ b/linden/indra/llcommon/llworkerthread.h
@@ -194,7 +194,7 @@ protected:
         U32 mRequestPriority; // last priority set
 
 private:
-        LLMutex mMutex;
+        LLMutexRootPool mMutex;         // Use LLMutexRootPool since this object is created and destructed by multiple threads.
         LLAtomicU32 mWorkFlags;
 };
 
diff --git a/linden/indra/llcrashlogger/llcrashlogger.cpp b/linden/indra/llcrashlogger/llcrashlogger.cpp
index 69e0adb..a399a48 100755
--- a/linden/indra/llcrashlogger/llcrashlogger.cpp
+++ b/linden/indra/llcrashlogger/llcrashlogger.cpp
@@ -387,8 +387,7 @@ bool LLCrashLogger::init()
                 return false;
         }
 
-        gServicePump = new LLPumpIO(gAPRPoolp);
-        gServicePump->prime(gAPRPoolp);
+        gServicePump = new LLPumpIO;
         LLHTTPClient::setPump(*gServicePump);
 
         //If we've opened the crash logger, assume we can delete the marker file if it exists   
diff --git a/linden/indra/llimage/llimage.cpp b/linden/indra/llimage/llimage.cpp
index 776c481..e933750 100644
--- a/linden/indra/llimage/llimage.cpp
+++ b/linden/indra/llimage/llimage.cpp
@@ -57,7 +57,7 @@ LLMutex* LLImage::sMutex = NULL;
 //static
 void LLImage::initClass(const bool& useDSO)
 {
-        sMutex = new LLMutex(NULL);
+        sMutex = new LLMutex;
         if (useDSO)
         {
                 LLImageJ2C::openDSO();
diff --git a/linden/indra/llimage/llimagej2c.cpp b/linden/indra/llimage/llimagej2c.cpp
index b99ebff..9e88bcd 100644
--- a/linden/indra/llimage/llimagej2c.cpp
+++ b/linden/indra/llimage/llimagej2c.cpp
@@ -46,7 +46,7 @@ typedef const char* (*EngineInfoLLImageJ2CFunction)();
 CreateLLImageJ2CFunction j2cimpl_create_func;
 DestroyLLImageJ2CFunction j2cimpl_destroy_func;
 EngineInfoLLImageJ2CFunction j2cimpl_engineinfo_func;
-apr_pool_t *j2cimpl_dso_memory_pool;
+AIAPRPool j2cimpl_dso_memory_pool;
 apr_dso_handle_t *j2cimpl_dso_handle;
 
 //Declare the prototype for theses functions here, their functionality
@@ -81,13 +81,12 @@ void LLImageJ2C::openDSO()
                                        gDirUtilp->getExecutableDir());
 
         j2cimpl_dso_handle      = NULL;
-        j2cimpl_dso_memory_pool = NULL;
+        j2cimpl_dso_memory_pool.create();
 
         //attempt to load the shared library
-        apr_pool_create(&j2cimpl_dso_memory_pool, NULL);
         rv = apr_dso_load(&j2cimpl_dso_handle,
                                           dso_path.c_str(),
-                                          j2cimpl_dso_memory_pool);
+                                          j2cimpl_dso_memory_pool());
 
         //now, check for success
         if ( rv == APR_SUCCESS )
@@ -151,11 +150,7 @@ void LLImageJ2C::openDSO()
                         j2cimpl_dso_handle = NULL;
                 }
 
-                if ( j2cimpl_dso_memory_pool )
-                {
-                        apr_pool_destroy(j2cimpl_dso_memory_pool);
-                        j2cimpl_dso_memory_pool = NULL;
-                }
+                j2cimpl_dso_memory_pool.destroy();
         }
 }
 
@@ -163,7 +158,7 @@ void LLImageJ2C::openDSO()
 void LLImageJ2C::closeDSO()
 {
         if ( j2cimpl_dso_handle ) apr_dso_unload(j2cimpl_dso_handle);
-        if (j2cimpl_dso_memory_pool) apr_pool_destroy(j2cimpl_dso_memory_pool);
+        j2cimpl_dso_memory_pool.destroy();
 }
 
 //static
diff --git a/linden/indra/llimage/llimageworker.cpp b/linden/indra/llimage/llimageworker.cpp
index 558a968..dc989e5 100644
--- a/linden/indra/llimage/llimageworker.cpp
+++ b/linden/indra/llimage/llimageworker.cpp
@@ -41,14 +41,13 @@
 LLImageDecodeThread::LLImageDecodeThread(bool threaded)
         : LLQueuedThread("imagedecode", threaded)
 {
-        mCreationMutex = new LLMutex(getAPRPool());
 }
 
 // MAIN THREAD
 // virtual
 S32 LLImageDecodeThread::update(U32 max_time_ms)
 {
-        LLMutexLock lock(mCreationMutex);
+        LLMutexLock lock(&mCreationMutex);
         for (creation_list_t::iterator iter = mCreationList.begin();
                  iter != mCreationList.end(); ++iter)
         {
@@ -71,7 +70,7 @@ S32 LLImageDecodeThread::update(U32 max_time_ms)
 LLImageDecodeThread::handle_t LLImageDecodeThread::decodeImage(LLImageFormatted* image, 
         U32 priority, S32 discard, BOOL needs_aux, Responder* responder)
 {
-        LLMutexLock lock(mCreationMutex);
+        LLMutexLock lock(&mCreationMutex);
         handle_t handle = generateHandle();
         mCreationList.push_back(creation_info(handle, image, priority, discard, needs_aux, responder));
         return handle;
@@ -81,7 +80,7 @@ LLImageDecodeThread::handle_t LLImageDecodeThread::decodeImage(LLImageFormatted*
 // Returns the size of the mutex guarded list as an indication of sanity
 S32 LLImageDecodeThread::tut_size()
 {
-        LLMutexLock lock(mCreationMutex);
+        LLMutexLock lock(&mCreationMutex);
         S32 res = mCreationList.size();
         return res;
 }
diff --git a/linden/indra/llimage/llimageworker.h b/linden/indra/llimage/llimageworker.h
index 0260206..fa2a8fa 100644
--- a/linden/indra/llimage/llimageworker.h
+++ b/linden/indra/llimage/llimageworker.h
@@ -101,7 +101,7 @@ private:
         };
         typedef std::list<creation_info> creation_list_t;
         creation_list_t mCreationList;
-        LLMutex* mCreationMutex;
+        LLMutex mCreationMutex;
 };
 
 #endif
diff --git a/linden/indra/llmath/llvolumemgr.cpp b/linden/indra/llmath/llvolumemgr.cpp
index 53641fc..8bfebcb 100644
--- a/linden/indra/llmath/llvolumemgr.cpp
+++ b/linden/indra/llmath/llvolumemgr.cpp
@@ -55,7 +55,7 @@ LLVolumeMgr::LLVolumeMgr()
 {
         // the LLMutex magic interferes with easy unit testing,
         // so you now must manually call useMutex() to use it
-        //mDataMutex = new LLMutex(gAPRPoolp);
+        //mDataMutex = new LLMutex;
 }
 
 LLVolumeMgr::~LLVolumeMgr()
@@ -222,7 +222,7 @@ void LLVolumeMgr::useMutex()
 { 
         if (!mDataMutex)
         {
-                mDataMutex = new LLMutex(gAPRPoolp);
+                mDataMutex = new LLMutex;
         }
 }
 
diff --git a/linden/indra/llmessage/CMakeLists.txt b/linden/indra/llmessage/CMakeLists.txt
index a5e4249..9965191 100644
--- a/linden/indra/llmessage/CMakeLists.txt
+++ b/linden/indra/llmessage/CMakeLists.txt
@@ -22,6 +22,7 @@ include_directories(
 set(llmessage_SOURCE_FILES
     llares.cpp
     llassetstorage.cpp
+    llavatarnamecache.cpp
     llblowfishcipher.cpp
     llbuffer.cpp
     llbufferstream.cpp
@@ -105,6 +106,7 @@ set(llmessage_HEADER_FILES
 
     llares.h
     llassetstorage.h
+    llavatarnamecache.h
     llblowfishcipher.h
     llbuffer.h
     llbufferstream.h
diff --git a/linden/indra/llmessage/llares.cpp b/linden/indra/llmessage/llares.cpp
index fe37fe8..5a6794e 100644
--- a/linden/indra/llmessage/llares.cpp
+++ b/linden/indra/llmessage/llares.cpp
@@ -43,6 +43,7 @@
 
 #include "llapr.h"
 #include "llares.h"
+#include "llscopedvolatileaprpool.h"
 
 #if defined(LL_WINDOWS)
 # define ns_c_in 1
@@ -463,11 +464,6 @@ void LLAres::search(const std::string &query, LLResType type,
 
 bool LLAres::process(U64 timeout)
 {
-        if (!gAPRPoolp)
-        {
-                ll_init_apr();
-        }
-
         int socks[ARES_GETSOCK_MAXNUM];
         apr_pollfd_t aprFds[ARES_GETSOCK_MAXNUM];
         apr_int32_t nsds = 0;   
@@ -481,10 +477,7 @@ bool LLAres::process(U64 timeout)
                 return nsds > 0;
         }
 
-        apr_status_t status;
-        LLAPRPool pool;
-        status = pool.getStatus() ;
-        ll_apr_assert_status(status);
+        LLScopedVolatileAPRPool scoped_pool;
 
         for (int i = 0; i < ARES_GETSOCK_MAXNUM; i++)
         {
@@ -501,7 +494,7 @@ bool LLAres::process(U64 timeout)
 
                 apr_socket_t *aprSock = NULL;
 
-                status = apr_os_sock_put(&aprSock, (apr_os_sock_t *) &socks[i], pool.getAPRPool());
+                apr_status_t status = apr_os_sock_put(&aprSock, (apr_os_sock_t *) &socks[i], scoped_pool);
                 if (status != APR_SUCCESS)
                 {
                         ll_apr_warn_status(status);
@@ -510,7 +503,7 @@ bool LLAres::process(U64 timeout)
 
                 aprFds[nactive].desc.s = aprSock;
                 aprFds[nactive].desc_type = APR_POLL_SOCKET;
-                aprFds[nactive].p = pool.getAPRPool();
+                aprFds[nactive].p = scoped_pool;
                 aprFds[nactive].rtnevents = 0;
                 aprFds[nactive].client_data = &socks[i];
 
@@ -519,7 +512,7 @@ bool LLAres::process(U64 timeout)
 
         if (nactive > 0)
         {
-                status = apr_poll(aprFds, nactive, &nsds, timeout);
+                apr_status_t status = apr_poll(aprFds, nactive, &nsds, timeout);
 
                 if (status != APR_SUCCESS && status != APR_TIMEUP)
                 {
diff --git a/linden/indra/llmessage/llavatarnamecache.cpp b/linden/indra/llmessage/llavatarnamecache.cpp
new file mode 100644
index 0000000..180274e
--- /dev/null
+++ b/linden/indra/llmessage/llavatarnamecache.cpp
@@ -0,0 +1,859 @@
+/** 
+ * @file llavatarnamecache.cpp
+ * @brief Provides lookup of avatar SLIDs ("bobsmith123") and display names
+ * ("James Cook") from avatar UUIDs.
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+#include "linden_common.h"
+
+#include "llavatarnamecache.h"
+
+#include "llcachename.h"                // we wrap this system
+#include "llframetimer.h"
+#include "llhttpclient.h"
+#include "llsd.h"
+#include "llsdserialize.h"
+
+#include <boost/tokenizer.hpp>
+
+#include <map>
+#include <set>
+
+namespace LLAvatarNameCache
+{
+        use_display_name_signal_t mUseDisplayNamesSignal;
+
+        // Manual override for display names: 0 = legacy names,
+        // 1 = display name and legacy name, 2 = display name (legacy if absent)
+        U32 sUseDisplayNames = 0;
+
+        // Cache starts in a paused state until we can determine if the
+        // current region supports display names.
+        bool sRunning = false;
+        
+        // Base lookup URL for name service.
+        // On simulator, loaded from indra.xml
+        // On viewer, usually a simulator capability (at People API team's request)
+        // Includes the trailing slash, like "http://pdp60.lindenlab.com:8000/agents/"
+        std::string sNameLookupURL;
+
+        // accumulated agent IDs for next query against service
+        typedef std::set<LLUUID> ask_queue_t;
+        ask_queue_t sAskQueue;
+
+        // agent IDs that have been requested, but with no reply
+        // maps agent ID to frame time request was made
+        typedef std::map<LLUUID, F64> pending_queue_t;
+        pending_queue_t sPendingQueue;
+
+        // Callbacks to fire when we received a name.
+        // May have multiple callbacks for a single ID, which are
+        // represented as multiple slots bound to the signal.
+        // Avoid copying signals via pointers.
+        typedef std::map<LLUUID, callback_signal_t*> signal_map_t;
+        signal_map_t sSignalMap;
+
+        // names we know about
+        typedef std::map<LLUUID, LLAvatarName> cache_t;
+        cache_t sCache;
+
+        // Send bulk lookup requests a few times a second at most
+        // only need per-frame timing resolution
+        LLFrameTimer sRequestTimer;
+
+        // Periodically clean out expired entries from the cache
+        //LLFrameTimer sEraseExpiredTimer;
+
+        //-----------------------------------------------------------------------
+        // Internal methods
+        //-----------------------------------------------------------------------
+
+        // Handle name response off network.
+        // Optionally skip adding to cache, used when this is a fallback to the
+        // legacy name system.
+        void processName(const LLUUID& agent_id,
+                                         const LLAvatarName& av_name,
+                                         bool add_to_cache);
+
+        void requestNamesViaCapability();
+
+        // Legacy name system callback
+        void legacyNameCallback(const LLUUID& agent_id,
+                                                        const std::string& first, const std::string& last,
+                                                        BOOL is_group, void* data);
+
+        void requestNamesViaLegacy();
+
+        // Fill in an LLAvatarName with the legacy name data
+        void buildLegacyName(const std::string& full_name,
+                                                 LLAvatarName* av_name);
+
+        // Do a single callback to a given slot
+        void fireSignal(const LLUUID& agent_id,
+                                        const callback_slot_t& slot,
+                                        const LLAvatarName& av_name);
+        
+        // Is a request in-flight over the network?
+        bool isRequestPending(const LLUUID& agent_id);
+
+        // Erase expired names from cache
+        void eraseExpired();
+
+        bool expirationFromCacheControl(LLSD headers, F64 *expires);
+}
+
+/* Sample response:
+<?xml version="1.0"?>
+<llsd>
+  <map>
+    <key>agents</key>
+    <array>
+      <map>
+        <key>display_name_next_update</key>
+        <date>2010-04-16T21:34:02+00:00Z</date>
+        <key>display_name_expires</key>
+        <date>2010-04-16T21:32:26.142178+00:00Z</date>
+        <key>display_name</key>
+        <string>MickBot390 LLQABot</string>
+        <key>sl_id</key>
+        <string>mickbot390.llqabot</string>
+        <key>id</key>
+        <string>0012809d-7d2d-4c24-9609-af1230a37715</string>
+        <key>is_display_name_default</key>
+        <boolean>false</boolean>
+      </map>
+      <map>
+        <key>display_name_next_update</key>
+        <date>2010-04-16T21:34:02+00:00Z</date>
+        <key>display_name_expires</key>
+        <date>2010-04-16T21:32:26.142178+00:00Z</date>
+        <key>display_name</key>
+        <string>Bjork Gudmundsdottir</string>
+        <key>sl_id</key>
+        <string>sardonyx.linden</string>
+        <key>id</key>
+        <string>3941037e-78ab-45f0-b421-bd6e77c1804d</string>
+        <key>is_display_name_default</key>
+        <boolean>true</boolean>
+      </map>
+    </array>
+  </map>
+</llsd>
+*/
+
+class LLAvatarNameResponder : public LLHTTPClient::Responder
+{
+private:
+        // need to store agent ids that are part of this request in case of
+        // an error, so we can flag them as unavailable
+        std::vector<LLUUID> mAgentIDs;
+
+        // Need the headers to look up Expires: and Retry-After:
+        LLSD mHeaders;
+        
+public:
+        LLAvatarNameResponder(const std::vector<LLUUID>& agent_ids)
+        :       mAgentIDs(agent_ids),
+                mHeaders()
+        { }
+        
+        /*virtual*/ void completedHeader(U32 status, const std::string& reason, 
+                const LLSD& headers)
+        {
+                mHeaders = headers;
+        }
+
+        /*virtual*/ void result(const LLSD& content)
+        {
+                // Pull expiration out of headers if available
+                F64 expires = LLAvatarNameCache::nameExpirationFromHeaders(mHeaders);
+
+                LLSD agents = content["agents"];
+                LLSD::array_const_iterator it;
+                for (it = agents.beginArray(); it != agents.endArray(); ++it)
+                {
+                        const LLSD& row = *it;
+                        LLUUID agent_id = row["id"].asUUID();
+
+                        LLAvatarName av_name;
+                        av_name.fromLLSD(row);
+
+                        // Use expiration time from header
+                        av_name.mExpires = expires;
+
+                        // Some avatars don't have explicit display names set
+                        if (av_name.mDisplayName.empty())
+                        {
+                                av_name.mDisplayName = av_name.mUsername;
+                        }
+
+                        // cache it and fire signals
+                        LLAvatarNameCache::processName(agent_id, av_name, true);
+                }
+
+                // Same logic as error response case
+                LLSD unresolved_agents = content["bad_ids"];
+                if (unresolved_agents.size() > 0)
+                {
+                        std::string first, last;
+                        LLAvatarName av_name;
+                        av_name.mIsDisplayNameDefault = false;
+                        av_name.mIsDummy = true;
+                        av_name.mExpires = expires;
+
+                        for (it = unresolved_agents.beginArray(); it != unresolved_agents.endArray(); ++it)
+                        {
+                                const LLUUID& agent_id = *it;
+                                gCacheName->getName(agent_id, first, last);
+                                av_name.mLegacyFirstName = first;
+                                av_name.mLegacyLastName = last;
+                                av_name.mDisplayName = first;
+                                if (last == "Resident")
+                                {
+                                        av_name.mDisplayName = first;
+                                        av_name.mUsername = first;
+                                }
+                                else
+                                {
+                                        av_name.mDisplayName = first + " " + last;
+                                        av_name.mUsername = first + "." + last;
+                                }
+                                LLStringUtil::toLower(av_name.mUsername);
+                                // cache it and fire signals
+                                LLAvatarNameCache::processName(agent_id, av_name, true);
+                        }
+                }
+        }
+
+        /*virtual*/ void error(U32 status, const std::string& reason)
+        {
+                // We're going to construct a dummy record and cache it for a while,
+                // either briefly for a 503 Service Unavailable, or longer for other
+                // errors.
+                F64 retry_timestamp = errorRetryTimestamp(status);
+
+                std::string first, last;
+                LLAvatarName av_name;
+                av_name.mIsDisplayNameDefault = false;
+                av_name.mIsDummy = true;
+                av_name.mExpires = retry_timestamp;
+
+                // Add dummy records for all agent IDs in this request
+                std::vector<LLUUID>::const_iterator it;
+                for (it = mAgentIDs.begin(); it != mAgentIDs.end(); ++it)
+                {
+                        const LLUUID& agent_id = *it;
+                        gCacheName->getName(agent_id, first, last);
+                        av_name.mLegacyFirstName = first;
+                        av_name.mLegacyLastName = last;
+                        av_name.mDisplayName = first;
+                        if (last == "Resident")
+                        {
+                                av_name.mDisplayName = first;
+                                av_name.mUsername = first;
+                        }
+                        else
+                        {
+                                av_name.mDisplayName = first + " " + last;
+                                av_name.mUsername = first + "." + last;
+                        }
+                        LLStringUtil::toLower(av_name.mUsername);
+                        // cache it and fire signals
+                        LLAvatarNameCache::processName(agent_id, av_name, true);
+                }
+        }
+
+        // Return time to retry a request that generated an error, based on
+        // error type and headers.  Return value is seconds-since-epoch.
+        F64 errorRetryTimestamp(S32 status)
+        {
+                F64 now = LLFrameTimer::getTotalSeconds();
+
+                // Retry-After takes priority
+                LLSD retry_after = mHeaders["retry-after"];
+                if (retry_after.isDefined())
+                {
+                        // We only support the delta-seconds type
+                        S32 delta_seconds = retry_after.asInteger();
+                        if (delta_seconds > 0)
+                        {
+                                // ...valid delta-seconds
+                                return now + F64(delta_seconds);
+                        }
+                }
+
+                // If no Retry-After, look for Cache-Control max-age
+                F64 expires = 0.0;
+                if (LLAvatarNameCache::expirationFromCacheControl(mHeaders, &expires))
+                {
+                        return expires;
+                }
+
+                // No information in header, make a guess
+                if (status == 503)
+                {
+                        // ...service unavailable, retry soon
+                        const F64 SERVICE_UNAVAILABLE_DELAY = 600.0; // 10 min
+                        return now + SERVICE_UNAVAILABLE_DELAY;
+                }
+                else
+                {
+                        // ...other unexpected error
+                        const F64 DEFAULT_DELAY = 3600.0; // 1 hour
+                        return now + DEFAULT_DELAY;
+                }
+        }
+};
+
+void LLAvatarNameCache::processName(const LLUUID& agent_id,
+                                                                        const LLAvatarName& av_name,
+                                                                        bool add_to_cache)
+{
+        if (add_to_cache)
+        {
+                sCache[agent_id] = av_name;
+        }
+
+        sPendingQueue.erase(agent_id);
+
+        // signal everyone waiting on this name
+        signal_map_t::iterator sig_it = sSignalMap.find(agent_id);
+        if (sig_it != sSignalMap.end())
+        {
+                callback_signal_t* signal = sig_it->second;
+                (*signal)(agent_id, av_name);
+
+                sSignalMap.erase(agent_id);
+
+                delete signal;
+                signal = NULL;
+        }
+}
+
+void LLAvatarNameCache::requestNamesViaCapability()
+{
+        F64 now = LLFrameTimer::getTotalSeconds();
+
+        // URL format is like:
+        // http://pdp60.lindenlab.com:8000/agents/?ids=3941037e-78ab-45f0-b421-bd6e77c1804d&ids=0012809d-7d2d-4c24-9609-af1230a37715&ids=0019aaba-24af-4f0a-aa72-6457953cf7f0
+        //
+        // Apache can handle URLs of 4096 chars, but let's be conservative
+        const U32 NAME_URL_MAX = 4096;
+        const U32 NAME_URL_SEND_THRESHOLD = 3000;
+        std::string url;
+        url.reserve(NAME_URL_MAX);
+
+        std::vector<LLUUID> agent_ids;
+        agent_ids.reserve(128);
+        
+        ask_queue_t::const_iterator it = sAskQueue.begin();
+        for ( ; it != sAskQueue.end(); ++it)
+        {
+                const LLUUID& agent_id = *it;
+
+                if (url.empty())
+                {
+                        // ...starting new request
+                        url += sNameLookupURL;
+                        url += "?ids=";
+                }
+                else
+                {
+                        // ...continuing existing request
+                        url += "&ids=";
+                }
+                url += agent_id.asString();
+                agent_ids.push_back(agent_id);
+
+                // mark request as pending
+                sPendingQueue[agent_id] = now;
+
+                if (url.size() > NAME_URL_SEND_THRESHOLD)
+                {
+                        //llinfos << "requestNames " << url << llendl;
+                        LLHTTPClient::get(url, new LLAvatarNameResponder(agent_ids));
+                        url.clear();
+                        agent_ids.clear();
+                }
+        }
+
+        if (!url.empty())
+        {
+                //llinfos << "requestNames " << url << llendl;
+                LLHTTPClient::get(url, new LLAvatarNameResponder(agent_ids));
+                url.clear();
+                agent_ids.clear();
+        }
+
+        // We've moved all asks to the pending request queue
+        sAskQueue.clear();
+}
+
+void LLAvatarNameCache::legacyNameCallback(const LLUUID& agent_id,
+                                                                                   const std::string& first, const std::string& last,
+                                                                                   BOOL is_group, void* data)
+{
+        std::string full_name = first + " " + last;
+        // Construct a dummy record for this name.  By convention, SLID is blank
+        // Never expires, but not written to disk, so lasts until end of session.
+        LLAvatarName av_name;
+        buildLegacyName(full_name, &av_name);
+
+        // Don't add to cache, the data already exists in the legacy name system
+        // cache and we don't want or need duplicate storage, because keeping the
+        // two copies in sync is complex.
+        processName(agent_id, av_name, false);
+}
+
+void LLAvatarNameCache::requestNamesViaLegacy()
+{
+        F64 now = LLFrameTimer::getTotalSeconds();
+        std::string full_name;
+        ask_queue_t::const_iterator it = sAskQueue.begin();
+        for (; it != sAskQueue.end(); ++it)
+        {
+                const LLUUID& agent_id = *it;
+
+                // Mark as pending first, just in case the callback is immediately
+                // invoked below.  This should never happen in practice.
+                sPendingQueue[agent_id] = now;
+
+                gCacheName->get(agent_id, false, legacyNameCallback);
+        }
+
+        // We've either answered immediately or moved all asks to the
+        // pending queue
+        sAskQueue.clear();
+}
+
+void LLAvatarNameCache::initClass(bool running)
+{
+        sRunning = running;
+}
+
+void LLAvatarNameCache::cleanupClass()
+{
+}
+
+void LLAvatarNameCache::importFile(std::istream& istr)
+{
+        LLSD data;
+        S32 parse_count = LLSDSerialize::fromXMLDocument(data, istr);
+        if (parse_count < 1) return;
+
+        // by convention LLSD storage is a map
+        // we only store one entry in the map
+        LLSD agents = data["agents"];
+
+        LLUUID agent_id;
+        LLAvatarName av_name;
+        LLSD::map_const_iterator it = agents.beginMap();
+        for ( ; it != agents.endMap(); ++it)
+        {
+                agent_id.set(it->first);
+                av_name.fromLLSD( it->second );
+                sCache[agent_id] = av_name;
+        }
+        // entries may have expired since we last ran the viewer, just
+        // clean them out now
+        eraseExpired();
+        llinfos << "loaded " << sCache.size() << llendl;
+}
+
+void LLAvatarNameCache::exportFile(std::ostream& ostr)
+{
+        LLSD agents;
+        cache_t::const_iterator it = sCache.begin();
+        for ( ; it != sCache.end(); ++it)
+        {
+                const LLUUID& agent_id = it->first;
+                const LLAvatarName& av_name = it->second;
+                if (!av_name.mIsDummy)
+                {
+                        // key must be a string
+                        agents[agent_id.asString()] = av_name.asLLSD();
+                }
+        }
+        LLSD data;
+        data["agents"] = agents;
+        LLSDSerialize::toPrettyXML(data, ostr);
+}
+
+void LLAvatarNameCache::setNameLookupURL(const std::string& name_lookup_url)
+{
+        sNameLookupURL = name_lookup_url;
+}
+
+bool LLAvatarNameCache::hasNameLookupURL()
+{
+        return !sNameLookupURL.empty();
+}
+
+void LLAvatarNameCache::idle()
+{
+        // By convention, start running at first idle() call
+        sRunning = true;
+
+        // *TODO: Possibly re-enabled this based on People API load measurements
+        // 100 ms is the threshold for "user speed" operations, so we can
+        // stall for about that long to batch up requests.
+        //const F32 SECS_BETWEEN_REQUESTS = 0.1f;
+        //if (!sRequestTimer.checkExpirationAndReset(SECS_BETWEEN_REQUESTS))
+        //{
+        //      return;
+        //}
+
+        // Must be large relative to above
+
+        // No longer deleting expired entries, just re-requesting in the get
+        // this way first synchronous get call on an expired entry won't return
+        // legacy name.  LF
+
+        //const F32 ERASE_EXPIRED_TIMEOUT = 60.f; // seconds
+        //if (sEraseExpiredTimer.checkExpirationAndReset(ERASE_EXPIRED_TIMEOUT))
+        //{
+        //      eraseExpired();
+        //}
+
+        if (sAskQueue.empty())
+        {
+                return;
+        }
+
+        if (useDisplayNames())
+        {
+                requestNamesViaCapability();
+        }
+        else
+        {
+                // ...fall back to legacy name cache system
+                requestNamesViaLegacy();
+        }
+}
+
+bool LLAvatarNameCache::isRequestPending(const LLUUID& agent_id)
+{
+        const F64 PENDING_TIMEOUT_SECS = 5.0 * 60.0;
+        F64 now = LLFrameTimer::getTotalSeconds();
+        F64 expire_time = now - PENDING_TIMEOUT_SECS;
+
+        pending_queue_t::const_iterator it = sPendingQueue.find(agent_id);
+        if (it != sPendingQueue.end())
+        {
+                bool request_expired = (it->second < expire_time);
+                return !request_expired;
+        }
+        return false;
+}
+
+void LLAvatarNameCache::eraseExpired()
+{
+        F64 now = LLFrameTimer::getTotalSeconds();
+        cache_t::iterator it = sCache.begin();
+        while (it != sCache.end())
+        {
+                cache_t::iterator cur = it;
+                ++it;
+                const LLAvatarName& av_name = cur->second;
+                if (av_name.mExpires < now)
+                {
+                        sCache.erase(cur);
+                }
+        }
+}
+
+void LLAvatarNameCache::buildLegacyName(const std::string& full_name,
+                                                                                LLAvatarName* av_name)
+{
+        llassert(av_name);
+        av_name->mUsername = "";
+        av_name->mDisplayName = full_name;
+        av_name->mIsDisplayNameDefault = true;
+        av_name->mIsDummy = true;
+        av_name->mExpires = F64_MAX;
+}
+
+// fills in av_name if it has it in the cache, even if expired (can check expiry time)
+// returns bool specifying  if av_name was filled, false otherwise
+bool LLAvatarNameCache::get(const LLUUID& agent_id, LLAvatarName *av_name)
+{
+        if (sRunning)
+        {
+                // ...only do immediate lookups when cache is running
+                if (useDisplayNames())
+                {
+                        // ...use display names cache
+                        std::map<LLUUID,LLAvatarName>::iterator it = sCache.find(agent_id);
+                        if (it != sCache.end())
+                        {
+                                *av_name = it->second;
+
+                                // re-request name if entry is expired
+                                if (av_name->mExpires < LLFrameTimer::getTotalSeconds())
+                                {
+                                        if (!isRequestPending(agent_id))
+                                        {
+                                                sAskQueue.insert(agent_id);
+                                        }
+                                }
+                                
+                                return true;
+                        }
+                }
+                else
+                {
+                        // ...use legacy names cache
+                        std::string full_name;
+                        if (gCacheName->getFullName(agent_id, full_name))
+                        {
+                                buildLegacyName(full_name, av_name);
+                                return true;
+                        }
+                }
+        }
+
+        if (!isRequestPending(agent_id))
+        {
+                sAskQueue.insert(agent_id);
+        }
+
+        return false;
+}
+
+void LLAvatarNameCache::fireSignal(const LLUUID& agent_id,
+                                                                   const callback_slot_t& slot,
+                                                                   const LLAvatarName& av_name)
+{
+        callback_signal_t signal;
+        signal.connect(slot);
+        signal(agent_id, av_name);
+}
+
+void LLAvatarNameCache::get(const LLUUID& agent_id, callback_slot_t slot)
+{
+        if (sRunning)
+        {
+                // ...only do immediate lookups when cache is running
+                if (useDisplayNames())
+                {
+                        // ...use new cache
+                        std::map<LLUUID,LLAvatarName>::iterator it = sCache.find(agent_id);
+                        if (it != sCache.end())
+                        {
+                                const LLAvatarName& av_name = it->second;
+                                
+                                if (av_name.mExpires > LLFrameTimer::getTotalSeconds())
+                                {
+                                        // ...name already exists in cache, fire callback now
+                                        fireSignal(agent_id, slot, av_name);
+
+                                        return;
+                                }
+                        }
+                }
+                else
+                {
+                        // ...use old name system
+                        std::string full_name;
+                        if (gCacheName->getFullName(agent_id, full_name))
+                        {
+                                LLAvatarName av_name;
+                                buildLegacyName(full_name, &av_name);
+                                fireSignal(agent_id, slot, av_name);
+                                return;
+                        }
+                }
+        }
+
+        // schedule a request
+        if (!isRequestPending(agent_id))
+        {
+                sAskQueue.insert(agent_id);
+        }
+
+        // always store additional callback, even if request is pending
+        signal_map_t::iterator sig_it = sSignalMap.find(agent_id);
+        if (sig_it == sSignalMap.end())
+        {
+                // ...new callback for this id
+                callback_signal_t* signal = new callback_signal_t();
+                signal->connect(slot);
+                sSignalMap[agent_id] = signal;
+        }
+        else
+        {
+                // ...existing callback, bind additional slot
+                callback_signal_t* signal = sig_it->second;
+                signal->connect(slot);
+        }
+}
+
+
+void LLAvatarNameCache::setUseDisplayNames(U32 use)
+{
+        if (use != sUseDisplayNames)
+        {
+                if (use > 2)
+                {
+                        sUseDisplayNames = 2;
+                }
+                else
+                {
+                        sUseDisplayNames = use;
+                }
+                // flush our cache
+                sCache.clear();
+
+                mUseDisplayNamesSignal();
+        }
+}
+
+U32 LLAvatarNameCache::useDisplayNames()
+{
+        // Must be both manually set on and able to look up names.
+        if (sNameLookupURL.empty())
+        {
+                return 0;
+        }
+        else
+        {
+                return sUseDisplayNames;
+        }
+}
+
+void LLAvatarNameCache::erase(const LLUUID& agent_id)
+{
+        sCache.erase(agent_id);
+}
+
+void LLAvatarNameCache::fetch(const LLUUID& agent_id)
+{
+        // re-request, even if request is already pending
+        sAskQueue.insert(agent_id);
+}
+
+void LLAvatarNameCache::insert(const LLUUID& agent_id, const LLAvatarName& av_name)
+{
+        // *TODO: update timestamp if zero?
+        sCache[agent_id] = av_name;
+}
+
+F64 LLAvatarNameCache::nameExpirationFromHeaders(LLSD headers)
+{
+        F64 expires = 0.0;
+        if (expirationFromCacheControl(headers, &expires))
+        {
+                return expires;
+        }
+        else
+        {
+                // With no expiration info, default to an hour
+                const F64 DEFAULT_EXPIRES = 60.0 * 60.0;
+                F64 now = LLFrameTimer::getTotalSeconds();
+                return now + DEFAULT_EXPIRES;
+        }
+}
+
+bool LLAvatarNameCache::expirationFromCacheControl(LLSD headers, F64 *expires)
+{
+        // Allow the header to override the default
+        LLSD cache_control_header = headers["cache-control"];
+        if (cache_control_header.isDefined())
+        {
+                S32 max_age = 0;
+                std::string cache_control = cache_control_header.asString();
+                if (max_age_from_cache_control(cache_control, &max_age))
+                {
+                        F64 now = LLFrameTimer::getTotalSeconds();
+                        *expires = now + (F64)max_age;
+                        return true;
+                }
+        }
+        return false;
+}
+
+
+void LLAvatarNameCache::addUseDisplayNamesCallback(const use_display_name_signal_t::slot_type& cb) 
+{ 
+        mUseDisplayNamesSignal.connect(cb); 
+}
+
+
+static const std::string MAX_AGE("max-age");
+static const boost::char_separator<char> EQUALS_SEPARATOR("=");
+static const boost::char_separator<char> COMMA_SEPARATOR(",");
+
+bool max_age_from_cache_control(const std::string& cache_control, S32 *max_age)
+{
+        // Split the string on "," to get a list of directives
+        typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
+        tokenizer directives(cache_control, COMMA_SEPARATOR);
+
+        tokenizer::iterator token_it = directives.begin();
+        for ( ; token_it != directives.end(); ++token_it)
+        {
+                // Tokens may have leading or trailing whitespace
+                std::string token = *token_it;
+                LLStringUtil::trim(token);
+
+                if (token.compare(0, MAX_AGE.size(), MAX_AGE) == 0)
+                {
+                        // ...this token starts with max-age, so let's chop it up by "="
+                        tokenizer subtokens(token, EQUALS_SEPARATOR);
+                        tokenizer::iterator subtoken_it = subtokens.begin();
+
+                        // Must have a token
+                        if (subtoken_it == subtokens.end()) return false;
+                        std::string subtoken = *subtoken_it;
+
+                        // Must exactly equal "max-age"
+                        LLStringUtil::trim(subtoken);
+                        if (subtoken != MAX_AGE) return false;
+
+                        // Must have another token
+                        ++subtoken_it;
+                        if (subtoken_it == subtokens.end()) return false;
+                        subtoken = *subtoken_it;
+
+                        // Must be a valid integer
+                        // *NOTE: atoi() returns 0 for invalid values, so we have to
+                        // check the string first.
+                        // *TODO: Do servers ever send "0000" for zero?  We don't handle it
+                        LLStringUtil::trim(subtoken);
+                        if (subtoken == "0")
+                        {
+                                *max_age = 0;
+                                return true;
+                        }
+                        S32 val = atoi( subtoken.c_str() );
+                        if (val > 0 && val < S32_MAX)
+                        {
+                                *max_age = val;
+                                return true;
+                        }
+                        return false;
+                }
+        }
+        return false;
+}
+
diff --git a/linden/indra/llmessage/llavatarnamecache.h b/linden/indra/llmessage/llavatarnamecache.h
new file mode 100644
index 0000000..a2519cd
--- /dev/null
+++ b/linden/indra/llmessage/llavatarnamecache.h
@@ -0,0 +1,105 @@
+/** 
+ * @file llavatarnamecache.h
+ * @brief Provides lookup of avatar SLIDs ("bobsmith123") and display names
+ * ("James Cook") from avatar UUIDs.
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LLAVATARNAMECACHE_H
+#define LLAVATARNAMECACHE_H
+
+#include "llavatarname.h"       // for convenience
+
+#include <boost/signals2.hpp>
+
+// We have display names support (this is for use by patches)
+#define LL_DISPLAY_NAMES
+
+class LLSD;
+class LLUUID;
+
+namespace LLAvatarNameCache
+{
+                
+        typedef boost::signals2::signal<void (void)> use_display_name_signal_t;
+
+        // Until the cache is set running, immediate lookups will fail and
+        // async lookups will be queued.  This allows us to block requests
+        // until we know if the first region supports display names.
+        void initClass(bool running);
+        void cleanupClass();
+
+        void importFile(std::istream& istr);
+        void exportFile(std::ostream& ostr);
+
+        // On the viewer, usually a simulator capabilitity
+        // If empty, name cache will fall back to using legacy name
+        // lookup system
+        void setNameLookupURL(const std::string& name_lookup_url);
+
+        // Do we have a valid lookup URL, hence are we trying to use the
+        // new display name lookup system?
+        bool hasNameLookupURL();
+        
+        // Periodically makes a batch request for display names not already in
+        // cache.  Call once per frame.
+        void idle();
+
+        // If name is in cache, returns true and fills in provided LLAvatarName
+        // otherwise returns false
+        bool get(const LLUUID& agent_id, LLAvatarName *av_name);
+
+        // Callback types for get() below
+        typedef boost::signals2::signal<
+                void (const LLUUID& agent_id, const LLAvatarName& av_name)>
+                        callback_signal_t;
+        typedef callback_signal_t::slot_type callback_slot_t;
+
+        // Fetches name information and calls callback.
+        // If name information is in cache, callback will be called immediately.
+        void get(const LLUUID& agent_id, callback_slot_t slot);
+
+        void setUseDisplayNames(U32 use);
+        U32 useDisplayNames();
+
+        void erase(const LLUUID& agent_id);
+
+        // Force a re-fetch of the most recent data, but keep the current
+        // data in cache
+        void fetch(const LLUUID& agent_id);
+
+        void insert(const LLUUID& agent_id, const LLAvatarName& av_name);
+
+        // Compute name expiration time from HTTP Cache-Control header,
+        // or return default value, in seconds from epoch.
+        F64 nameExpirationFromHeaders(LLSD headers);
+
+        void addUseDisplayNamesCallback(const use_display_name_signal_t::slot_type& cb);
+}
+
+// Parse a cache-control header to get the max-age delta-seconds.
+// Returns true if header has max-age param and it parses correctly.
+// Exported here to ease unit testing.
+bool max_age_from_cache_control(const std::string& cache_control, S32 *max_age);
+
+#endif
diff --git a/linden/indra/llmessage/llcachename.h b/linden/indra/llmessage/llcachename.h
index 2757b86..cb3cc1f 100644
--- a/linden/indra/llmessage/llcachename.h
+++ b/linden/indra/llmessage/llcachename.h
@@ -33,6 +33,8 @@
 #ifndef LL_LLCACHENAME_H
 #define LL_LLCACHENAME_H
 
+#include "llavatarnamecache.h"  // for convenience
+
 class LLMessageSystem;
 class LLHost;
 class LLUUID;
diff --git a/linden/indra/llmessage/llcurl.cpp b/linden/indra/llmessage/llcurl.cpp
index 202332c..9ecfee4 100644
--- a/linden/indra/llmessage/llcurl.cpp
+++ b/linden/indra/llmessage/llcurl.cpp
@@ -1020,7 +1020,7 @@ void LLCurl::initClass()
         S32 mutex_count = CRYPTO_num_locks();
         for (S32 i=0; i<mutex_count; i++)
         {
-                sSSLMutex.push_back(new LLMutex(NULL));
+                sSSLMutex.push_back(new LLMutex);
         }
         CRYPTO_set_id_callback(&LLCurl::ssl_thread_id);
         CRYPTO_set_locking_callback(&LLCurl::ssl_locking_callback);
diff --git a/linden/indra/llmessage/lliohttpserver.cpp b/linden/indra/llmessage/lliohttpserver.cpp
index 83dfa94..8ad052b 100644
--- a/linden/indra/llmessage/lliohttpserver.cpp
+++ b/linden/indra/llmessage/lliohttpserver.cpp
@@ -948,13 +948,9 @@ private:
 
 
 // static
-LLHTTPNode& LLIOHTTPServer::create(
-        apr_pool_t* pool, LLPumpIO& pump, U16 port)
+LLHTTPNode& LLIOHTTPServer::create(LLPumpIO& pump, U16 port)
 {
-        LLSocket::ptr_t socket = LLSocket::create(
-        pool,
-        LLSocket::STREAM_TCP,
-        port);
+        LLSocket::ptr_t socket = LLSocket::create(LLSocket::STREAM_TCP, port);
     if(!socket)
     {
         llerrs << "Unable to initialize socket" << llendl;
@@ -963,7 +959,7 @@ LLHTTPNode& LLIOHTTPServer::create(
     LLHTTPResponseFactory* factory = new LLHTTPResponseFactory;
         boost::shared_ptr<LLChainIOFactory> factory_ptr(factory);
 
-    LLIOServerSocket* server = new LLIOServerSocket(pool, socket, factory_ptr);
+    LLIOServerSocket* server = new LLIOServerSocket(socket, factory_ptr);
 
         LLPumpIO::chain_t chain;
     chain.push_back(LLIOPipe::ptr_t(server));
diff --git a/linden/indra/llmessage/lliohttpserver.h b/linden/indra/llmessage/lliohttpserver.h
index d1c9bdd..d2a8e2a 100644
--- a/linden/indra/llmessage/lliohttpserver.h
+++ b/linden/indra/llmessage/lliohttpserver.h
@@ -57,7 +57,7 @@ class LLIOHTTPServer
 public:
         typedef void (*timing_callback_t)(const char* hashed_name, F32 time, void* data);
 
-        static LLHTTPNode& create(apr_pool_t* pool, LLPumpIO& pump, U16 port);
+        static LLHTTPNode& create(LLPumpIO& pump, U16 port);
         /**< Creates an HTTP wire server on the pump for the given TCP port.
          *
          *   Returns the root node of the new server.  Add LLHTTPNode instances
diff --git a/linden/indra/llmessage/lliosocket.cpp b/linden/indra/llmessage/lliosocket.cpp
index 7ec577c..686c037 100644
--- a/linden/indra/llmessage/lliosocket.cpp
+++ b/linden/indra/llmessage/lliosocket.cpp
@@ -41,6 +41,7 @@
 #include "llhost.h"
 #include "llmemtype.h"
 #include "llpumpio.h"
+#include "llthread.h"
 
 //
 // constants
@@ -104,51 +105,31 @@ void ll_debug_socket(const char* msg, apr_socket_t* apr_sock)
 ///
 
 // static
-LLSocket::ptr_t LLSocket::create(apr_pool_t* pool, EType type, U16 port)
+LLSocket::ptr_t LLSocket::create(EType type, U16 port)
 {
         LLMemType m1(LLMemType::MTYPE_IO_TCP);
-        LLSocket::ptr_t rv;
-        apr_socket_t* socket = NULL;
-        apr_pool_t* new_pool = NULL;
         apr_status_t status = APR_EGENERAL;
-
-        // create a pool for the socket
-        status = apr_pool_create(&new_pool, pool);
-        if(ll_apr_warn_status(status))
-        {
-                if(new_pool) apr_pool_destroy(new_pool);
-                return rv;
-        }
+        LLSocket::ptr_t rv(new LLSocket);
 
         if(STREAM_TCP == type)
         {
-                status = apr_socket_create(
-                        &socket,
-                        APR_INET,
-                        SOCK_STREAM,
-                        APR_PROTO_TCP,
-                        new_pool);
+                status = apr_socket_create(&rv->mSocket, APR_INET, SOCK_STREAM, APR_PROTO_TCP, rv->mPool());
         }
         else if(DATAGRAM_UDP == type)
         {
-                status = apr_socket_create(
-                        &socket,
-                        APR_INET,
-                        SOCK_DGRAM,
-                        APR_PROTO_UDP,
-                        new_pool);
+                status = apr_socket_create(&rv->mSocket, APR_INET, SOCK_DGRAM, APR_PROTO_UDP, rv->mPool());
         }
         else
         {
-                if(new_pool) apr_pool_destroy(new_pool);
+                rv.reset();
                 return rv;
         }
         if(ll_apr_warn_status(status))
         {
-                if(new_pool) apr_pool_destroy(new_pool);
+                rv->mSocket = NULL;
+                rv.reset();
                 return rv;
         }
-        rv = ptr_t(new LLSocket(socket, new_pool));
         if(port > 0)
         {
                 apr_sockaddr_t* sa = NULL;
@@ -158,7 +139,7 @@ LLSocket::ptr_t LLSocket::create(apr_pool_t* pool, EType type, U16 port)
                         APR_UNSPEC,
                         port,
                         0,
-                        new_pool);
+                        rv->mPool());
                 if(ll_apr_warn_status(status))
                 {
                         rv.reset();
@@ -166,8 +147,8 @@ LLSocket::ptr_t LLSocket::create(apr_pool_t* pool, EType type, U16 port)
                 }
                 // This allows us to reuse the address on quick down/up. This
                 // is unlikely to create problems.
-                ll_apr_warn_status(apr_socket_opt_set(socket, APR_SO_REUSEADDR, 1));
-                status = apr_socket_bind(socket, sa);
+                ll_apr_warn_status(apr_socket_opt_set(rv->mSocket, APR_SO_REUSEADDR, 1));
+                status = apr_socket_bind(rv->mSocket, sa);
                 if(ll_apr_warn_status(status))
                 {
                         rv.reset();
@@ -181,7 +162,7 @@ LLSocket::ptr_t LLSocket::create(apr_pool_t* pool, EType type, U16 port)
                         // to keep a queue of incoming connections for ACCEPT.
                         lldebugs << "Setting listen state for socket." << llendl;
                         status = apr_socket_listen(
-                                socket,
+                                rv->mSocket,
                                 LL_DEFAULT_LISTEN_BACKLOG);
                         if(ll_apr_warn_status(status))
                         {
@@ -202,21 +183,28 @@ LLSocket::ptr_t LLSocket::create(apr_pool_t* pool, EType type, U16 port)
 }
 
 // static
-LLSocket::ptr_t LLSocket::create(apr_socket_t* socket, apr_pool_t* pool)
+LLSocket::ptr_t LLSocket::create(apr_status_t& status, LLSocket::ptr_t& listen_socket)
 {
         LLMemType m1(LLMemType::MTYPE_IO_TCP);
-        LLSocket::ptr_t rv;
-        if(!socket)
+        if (!listen_socket->getSocket())
+        {
+                status = APR_ENOSOCKET;
+                return LLSocket::ptr_t();
+        }
+        LLSocket::ptr_t rv(new LLSocket);
+        lldebugs << "accepting socket" << llendl;
+        status = apr_socket_accept(&rv->mSocket, listen_socket->getSocket(), rv->mPool());
+        if (status != APR_SUCCESS)
         {
+                rv->mSocket = NULL;
+                rv.reset();
                 return rv;
         }
-        rv = ptr_t(new LLSocket(socket, pool));
         rv->mPort = PORT_EPHEMERAL;
         rv->setOptions();
         return rv;
 }
 
-
 bool LLSocket::blockingConnect(const LLHost& host)
 {
         if(!mSocket) return false;
@@ -229,7 +217,7 @@ bool LLSocket::blockingConnect(const LLHost& host)
                 APR_UNSPEC,
                 host.getPort(),
                 0,
-                mPool)))
+                mPool())))
         {
                 return false;
         }
@@ -240,13 +228,11 @@ bool LLSocket::blockingConnect(const LLHost& host)
         return true;
 }
 
-LLSocket::LLSocket(apr_socket_t* socket, apr_pool_t* pool) :
-        mSocket(socket),
-        mPool(pool),
+LLSocket::LLSocket() :
+        mSocket(NULL),
+        mPool(LLThread::tldata().mRootPool),
         mPort(PORT_INVALID)
 {
-        ll_debug_socket("Constructing wholely formed socket", mSocket);
-        LLMemType m1(LLMemType::MTYPE_IO_TCP);
 }
 
 LLSocket::~LLSocket()
@@ -258,10 +244,6 @@ LLSocket::~LLSocket()
                 ll_debug_socket("Destroying socket", mSocket);
                 apr_socket_close(mSocket);
         }
-        if(mPool)
-        {
-                apr_pool_destroy(mPool);
-        }
 }
 
 void LLSocket::setOptions()
@@ -522,10 +504,8 @@ LLIOPipe::EStatus LLIOSocketWriter::process_impl(
 ///
 
 LLIOServerSocket::LLIOServerSocket(
-        apr_pool_t* pool,
         LLIOServerSocket::socket_t listener,
         factory_t factory) :
-        mPool(pool),
         mListenSocket(listener),
         mReactor(factory),
         mInitialized(false),
@@ -585,21 +565,15 @@ LLIOPipe::EStatus LLIOServerSocket::process_impl(
         lldebugs << "accepting socket" << llendl;
 
         PUMP_DEBUG;
-        apr_pool_t* new_pool = NULL;
-        apr_status_t status = apr_pool_create(&new_pool, mPool);
-        apr_socket_t* socket = NULL;
-        status = apr_socket_accept(
-                &socket,
-                mListenSocket->getSocket(),
-                new_pool);
-        LLSocket::ptr_t llsocket(LLSocket::create(socket, new_pool));
+        apr_status_t status;
+        LLSocket::ptr_t llsocket(LLSocket::create(status, mListenSocket));
         //EStatus rv = STATUS_ERROR;
-        if(llsocket)
+        if(llsocket && status == APR_SUCCESS)
         {
                 PUMP_DEBUG;
 
                 apr_sockaddr_t* remote_addr;
-                apr_socket_addr_get(&remote_addr, APR_REMOTE, socket);
+                apr_socket_addr_get(&remote_addr, APR_REMOTE, llsocket->getSocket());
                 
                 char* remote_host_string;
                 apr_sockaddr_ip_get(&remote_host_string, remote_addr);
@@ -614,7 +588,6 @@ LLIOPipe::EStatus LLIOServerSocket::process_impl(
                 {
                         chain.push_back(LLIOPipe::ptr_t(new LLIOSocketWriter(llsocket)));
                         pump->addChain(chain, mResponseTimeout);
-                        status = STATUS_OK;
                 }
                 else
                 {
@@ -623,7 +596,8 @@ LLIOPipe::EStatus LLIOServerSocket::process_impl(
         }
         else
         {
-                llwarns << "Unable to create linden socket." << llendl;
+                char buf[256];
+                llwarns << "Unable to accept linden socket: " << apr_strerror(status, buf, sizeof(buf)) << llendl;
         }
 
         PUMP_DEBUG;
@@ -636,11 +610,10 @@ LLIOPipe::EStatus LLIOServerSocket::process_impl(
 #if 0
 LLIODataSocket::LLIODataSocket(
         U16 suggested_port,
-        U16 start_discovery_port,
-        apr_pool_t* pool) : 
+        U16 start_discovery_port) :
         mSocket(NULL)
 {
-        if(!pool || (PORT_INVALID == suggested_port)) return;
+        if(PORT_INVALID == suggested_port) return;
         if(ll_apr_warn_status(apr_socket_create(&mSocket, APR_INET, SOCK_DGRAM, APR_PROTO_UDP, pool))) return;
         apr_sockaddr_t* sa = NULL;
         if(ll_apr_warn_status(apr_sockaddr_info_get(&sa, APR_ANYADDR, APR_UNSPEC, suggested_port, 0, pool))) return;
diff --git a/linden/indra/llmessage/lliosocket.h b/linden/indra/llmessage/lliosocket.h
index ec09ad8..5ad75e9 100644
--- a/linden/indra/llmessage/lliosocket.h
+++ b/linden/indra/llmessage/lliosocket.h
@@ -44,7 +44,6 @@
  */
 
 #include "lliopipe.h"
-#include "apr_pools.h"
 #include "apr_network_io.h"
 #include "llchainio.h"
 
@@ -94,34 +93,22 @@ public:
          * socket. If you intend the socket to be known to external
          * clients without prior port notification, do not use
          * PORT_EPHEMERAL.
-         * @param pool The apr pool to use. A child pool will be created
-         * and associated with the socket.
          * @param type The type of socket to create
          * @param port The port for the socket
          * @return A valid socket shared pointer if the call worked.
          */
         static ptr_t create(
-                apr_pool_t* pool,
                 EType type,
                 U16 port = PORT_EPHEMERAL);
 
         /** 
-         * @brief Create a LLSocket when you already have an apr socket.
+         * @brief Create a LLSocket by accepting a connection from a listen socket.
          *
-         * This method assumes an ephemeral port. This is typically used
-         * by calls which spawn a socket such as a call to
-         * <code>accept()</code> as in the server socket. This call should
-         * not fail if you have a valid apr socket.
-         * Because of the nature of how accept() works, you are expected
-         * to create a new pool for the socket, use that pool for the
-         * accept, and pass it in here where it will be bound with the
-         * socket and destroyed at the same time.
-         * @param socket The apr socket to use 
-         * @param pool The pool used to create the socket. *NOTE: The pool
-         * passed in will be DESTROYED.
+         * @param status Output. Status of the accept if a valid listen socket was passed.
+         * @param listen_socket The listen socket to use.
          * @return A valid socket shared pointer if the call worked.
          */
-        static ptr_t create(apr_socket_t* socket, apr_pool_t* pool);
+        static ptr_t create(apr_status_t& status, ptr_t& listen_socket);
 
         /** 
          * @brief Perform a blocking connect to a host. Do not use in production.
@@ -156,7 +143,7 @@ protected:
          * @brief Protected constructor since should only make sockets
          * with one of the two <code>create()</code> calls.
          */
-        LLSocket(apr_socket_t* socket, apr_pool_t* pool);
+        LLSocket(void);
 
         /** 
          * @brief Set default socket options.
@@ -173,8 +160,8 @@ protected:
         // The apr socket.
         apr_socket_t* mSocket;
 
-        // our memory pool
-        apr_pool_t* mPool;
+        // Our memory pool.
+        AIAPRPool mPool;
 
         // The port if we know it.
         U16 mPort;
@@ -299,7 +286,7 @@ class LLIOServerSocket : public LLIOPipe
 public:
         typedef LLSocket::ptr_t socket_t;
         typedef boost::shared_ptr<LLChainIOFactory> factory_t;
-        LLIOServerSocket(apr_pool_t* pool, socket_t listener, factory_t reactor);
+        LLIOServerSocket(socket_t listener, factory_t reactor);
         virtual ~LLIOServerSocket();
 
         /** 
@@ -331,7 +318,6 @@ protected:
         //@}
 
 protected:
-        apr_pool_t* mPool;
         socket_t mListenSocket;
         factory_t mReactor;
         bool mInitialized;
@@ -365,8 +351,7 @@ public:
          */
         LLIODataSocket(
                 U16 suggested_port,
-                U16 start_discovery_port,
-                apr_pool_t* pool);
+                U16 start_discovery_port);
         virtual ~LLIODataSocket();
 
 protected:
diff --git a/linden/indra/llmessage/llmail.cpp b/linden/indra/llmessage/llmail.cpp
index d52ff6c..8850e29 100644
--- a/linden/indra/llmessage/llmail.cpp
+++ b/linden/indra/llmessage/llmail.cpp
@@ -56,6 +56,7 @@
 #include "llstring.h"
 #include "lluuid.h"
 #include "net.h"
+#include "aiaprpool.h"
 
 //
 // constants
@@ -63,7 +64,7 @@
 const size_t LL_MAX_KNOWN_GOOD_MAIL_SIZE = 4096;
 
 static bool gMailEnabled = true;
-static apr_pool_t* gMailPool;
+static AIAPRPool gMailPool;
 static apr_sockaddr_t* gSockAddr;
 static apr_socket_t* gMailSocket;
 
@@ -88,7 +89,7 @@ bool connect_smtp()
                 gSockAddr->sa.sin.sin_family,
                 SOCK_STREAM,
                 APR_PROTO_TCP,
-                gMailPool);
+                gMailPool());
         if(ll_apr_warn_status(status)) return false;
         status = apr_socket_connect(gMailSocket, gSockAddr);
         if(ll_apr_warn_status(status))
@@ -145,19 +146,19 @@ BOOL LLMail::send(
 }
 
 // static
-void LLMail::init(const std::string& hostname, apr_pool_t* pool)
+void LLMail::init(const std::string& hostname)
 {
         gMailSocket = NULL;
-        if(hostname.empty() || !pool)
+        if (hostname.empty())
         {
-                gMailPool = NULL;
                 gSockAddr = NULL;
+                gMailPool.destroy();
         }
         else
         {
-                gMailPool = pool;
+                gMailPool.create();
 
-                // collect all the information into a socaddr sturcture. the
+                // Collect all the information into a sockaddr structure. the
                 // documentation is a bit unclear, but I either have to
                 // specify APR_UNSPEC or not specify any flags. I am not sure
                 // which option is better.
@@ -167,7 +168,7 @@ void LLMail::init(const std::string& hostname, apr_pool_t* pool)
                         APR_UNSPEC,
                         25,
                         APR_IPV4_ADDR_OK,
-                        gMailPool);
+                        gMailPool());
                 ll_apr_warn_status(status);
         }
 }
diff --git a/linden/indra/llmessage/llmail.h b/linden/indra/llmessage/llmail.h
index 7effb84..7026d93 100644
--- a/linden/indra/llmessage/llmail.h
+++ b/linden/indra/llmessage/llmail.h
@@ -33,15 +33,13 @@
 #ifndef LL_LLMAIL_H
 #define LL_LLMAIL_H
 
-typedef struct apr_pool_t apr_pool_t;
-
 #include "llsd.h"
 
 class LLMail
 {
 public:
         // if hostname is NULL, then the host is resolved as 'mail'
-        static void init(const std::string& hostname, apr_pool_t* pool);
+        static void init(const std::string& hostname);
 
         // Allow all email transmission to be disabled/enabled.
         static void enable(bool mail_enabled);
diff --git a/linden/indra/llmessage/llpartdata.cpp b/linden/indra/llmessage/llpartdata.cpp
index 485bc6a..a2811ab 100644
--- a/linden/indra/llmessage/llpartdata.cpp
+++ b/linden/indra/llmessage/llpartdata.cpp
@@ -347,3 +347,93 @@ void LLPartSysData::setPartAccel(const LLVector3 &accel)
         mPartAccel.mV[VY] = llclamp(accel.mV[VY], -100.f, 100.f);
         mPartAccel.mV[VZ] = llclamp(accel.mV[VZ], -100.f, 100.f);
 }
+
+LLSD LLPartSysData::asLLSD() const
+{
+        LLSD sd = LLSD();
+
+        sd["LL_PART_INTERP_COLOR_MASK"]         = (LLPartData::LL_PART_INTERP_COLOR_MASK  & mPartData.mFlags) ? 1 : 0;
+        sd["LL_PART_INTERP_SCALE_MASK"]         = (LLPartData::LL_PART_INTERP_SCALE_MASK  & mPartData.mFlags) ? 1 : 0;
+        sd["LL_PART_BOUNCE_MASK"]               = (LLPartData::LL_PART_BOUNCE_MASK  & mPartData.mFlags) ? 1 : 0;
+        sd["LL_PART_WIND_MASK"]                 = (LLPartData::LL_PART_WIND_MASK  & mPartData.mFlags) ? 1 : 0;
+        sd["LL_PART_FOLLOW_SRC_MASK"]           = (LLPartData::LL_PART_FOLLOW_SRC_MASK  & mPartData.mFlags) ? 1 : 0;
+        sd["LL_PART_FOLLOW_VELOCITY_MASK"]      = (LLPartData::LL_PART_FOLLOW_VELOCITY_MASK  & mPartData.mFlags) ? 1 : 0;
+        sd["LL_PART_TARGET_POS_MASK"]           = (LLPartData::LL_PART_TARGET_POS_MASK  & mPartData.mFlags) ? 1 : 0;
+        sd["LL_PART_TARGET_LINEAR_MASK"]        = (LLPartData::LL_PART_TARGET_LINEAR_MASK  & mPartData.mFlags) ? 1 : 0;
+        sd["LL_PART_EMISSIVE_MASK"]             = (LLPartData::LL_PART_EMISSIVE_MASK  & mPartData.mFlags) ? 1 : 0;
+        sd["LL_PART_BEAM_MASK"]                 = (LLPartData::LL_PART_BEAM_MASK  & mPartData.mFlags) ? 1 : 0;
+
+        sd["SourceMaxage"] = mPartData.mMaxAge;
+        sd["Startcolor"] = ll_sd_from_color4(mPartData.mStartColor);
+        sd["Endcolor"] = ll_sd_from_color4(mPartData.mEndColor);
+        sd["Startscale"] = ll_sd_from_vector2(mPartData.mStartScale);
+        sd["Endscale"] = ll_sd_from_vector2(mPartData.mEndScale);
+
+        sd["ParticleMaxAge"] = mMaxAge;
+        sd["ParticleStartAge"] = mStartAge;
+
+
+        sd["LL_PART_SRC_PATTERN_DROP"] = ( mPattern & LL_PART_SRC_PATTERN_DROP) ? 1 : 0;
+        sd["LL_PART_SRC_PATTERN_EXPLODE"] = ( mPattern & LL_PART_SRC_PATTERN_EXPLODE) ? 1 : 0;
+        sd["LL_PART_SRC_PATTERN_ANGLE"] = ( mPattern & LL_PART_SRC_PATTERN_ANGLE) ? 1 : 0;
+        sd["LL_PART_SRC_PATTERN_ANGLE_CONE"] = ( mPattern & LL_PART_SRC_PATTERN_ANGLE_CONE) ? 1 : 0 ;
+        sd["LL_PART_SRC_PATTERN_ANGLE_CONE_EMPTY"] = ( mPattern & LL_PART_SRC_PATTERN_ANGLE_CONE_EMPTY) ? 1 : 0;
+
+        sd["InnerAngle"] = mInnerAngle;
+        sd["OuterAngle"] = mOuterAngle;
+        sd["AngularVelocity"] = ll_sd_from_vector3(mAngularVelocity);
+        sd["BurstRate"] = mBurstRate;
+        sd["BurstPartCount"] = mBurstPartCount;
+        sd["BurstSpeedMin"] = mBurstSpeedMin;
+        sd["BurstSpeedMax"] = mBurstSpeedMax;
+        sd["BurstRadius"] = mBurstRadius;
+        sd["PartImageID"] = mPartImageID.asString();
+        sd["TargetId"]  = mTargetUUID.asString();
+        return sd;
+}
+
+bool LLPartSysData::fromLLSD(LLSD& sd)
+{
+        mPartData.mFlags = 0;
+        if (sd["LL_PART_INTERP_COLOR_MASK"])    mPartData.mFlags |=  LLPartData::LL_PART_INTERP_COLOR_MASK;
+        if (sd["LL_PART_INTERP_SCALE_MASK"])    mPartData.mFlags |=  LLPartData::LL_PART_INTERP_SCALE_MASK;
+        if (sd["LL_PART_BOUNCE_MASK"])          mPartData.mFlags |= LLPartData::LL_PART_BOUNCE_MASK;
+        if (sd["LL_PART_WIND_MASK"])            mPartData.mFlags |= LLPartData::LL_PART_WIND_MASK;
+        if (sd["LL_PART_FOLLOW_SRC_MASK"])      mPartData.mFlags |= LLPartData::LL_PART_FOLLOW_SRC_MASK;
+        if (sd["LL_PART_FOLLOW_VELOCITY_MASK"]) mPartData.mFlags |= LLPartData::LL_PART_FOLLOW_VELOCITY_MASK;
+        if (sd["LL_PART_TARGET_POS_MASK"])      mPartData.mFlags |= LLPartData::LL_PART_TARGET_POS_MASK;
+        if (sd["LL_PART_TARGET_LINEAR_MASK"])   mPartData.mFlags |= LLPartData::LL_PART_TARGET_LINEAR_MASK;
+        if (sd["LL_PART_EMISSIVE_MASK"])        mPartData.mFlags |= LLPartData::LL_PART_EMISSIVE_MASK;
+        if (sd["LL_PART_BEAM_MASK"])            mPartData.mFlags |= LLPartData::LL_PART_BEAM_MASK;
+
+        mPartData.mMaxAge = (F32)sd["SourceMaxage"].asReal();
+        mPartData.mStartColor = ll_color4_from_sd(sd["Startcolor"]);
+        mPartData.mEndColor = ll_color4_from_sd(sd["Endcolor"]);
+        mPartData.mStartScale = ll_vector2_from_sd(sd["Startscale"]);
+        mPartData.mEndScale = ll_vector2_from_sd(sd["Endscale"]);
+
+        mMaxAge         = (F32)sd["ParticleMaxAge"].asReal();
+        mStartAge       = (F32)sd["ParticleStartAge"].asReal();
+
+        mPattern = 0;
+        if (sd["LL_PART_SRC_PATTERN_DROP"])             mPattern |= LL_PART_SRC_PATTERN_DROP;
+        if (sd["LL_PART_SRC_PATTERN_EXPLODE"])          mPattern |= LL_PART_SRC_PATTERN_EXPLODE; 
+        if (sd["LL_PART_SRC_PATTERN_ANGLE"])            mPattern |= LL_PART_SRC_PATTERN_ANGLE;
+        if (sd["LL_PART_SRC_PATTERN_ANGLE_CONE"])       mPattern |= LL_PART_SRC_PATTERN_ANGLE_CONE;
+        if (sd["LL_PART_SRC_PATTERN_ANGLE_CONE_EMPTY"]) mPattern |= LL_PART_SRC_PATTERN_ANGLE_CONE_EMPTY;
+
+        mInnerAngle             = (F32)sd["InnerAngle"].asReal();
+        mOuterAngle             = (F32)sd["OuterAngle"].asReal();
+        mAngularVelocity        = ll_vector3_from_sd(sd["AngularVelocity"]);
+        mBurstRate              = (F32)sd["BurstRate"].asReal();
+        int burst_part_count    = sd["BurstPartCount"];
+        mBurstPartCount         = (U8)burst_part_count;
+        mBurstSpeedMin          = (F32)sd["BurstSpeedMin"].asReal();
+        mBurstSpeedMax          = (F32)sd["BurstSpeedMax"].asReal();
+        mBurstRadius            = (F32)sd["BurstRadius"].asReal();
+
+        mPartImageID    = LLUUID(sd[("PartImageID")].asString());
+        mTargetUUID     = LLUUID(sd["TargetId"].asString());
+
+        return true;
+}
\ No newline at end of file
diff --git a/linden/indra/llmessage/llpartdata.h b/linden/indra/llmessage/llpartdata.h
index 6dcb311..b7efa95 100644
--- a/linden/indra/llmessage/llpartdata.h
+++ b/linden/indra/llmessage/llpartdata.h
@@ -158,6 +158,9 @@ public:
         BOOL unpackBlock(const S32 block_num);
         BOOL packBlock();
 
+        LLSD asLLSD() const;
+        bool fromLLSD(LLSD& sd);
+
         static BOOL packNull();
         static BOOL isNullPS(const S32 block_num); // Returns FALSE if this is a "NULL" particle system (i.e. no system)
 
diff --git a/linden/indra/llmessage/llpumpio.cpp b/linden/indra/llmessage/llpumpio.cpp
index 8ef2b16..6f10c6b 100644
--- a/linden/indra/llmessage/llpumpio.cpp
+++ b/linden/indra/llmessage/llpumpio.cpp
@@ -43,6 +43,7 @@
 #include "llmemtype.h"
 #include "llstl.h"
 #include "llstat.h"
+#include "llthread.h"
 #include "llfasttimer.h"
 
 // These should not be enabled in production, but they can be
@@ -169,14 +170,12 @@ struct ll_delete_apr_pollset_fd_client_data
 /**
  * LLPumpIO
  */
-LLPumpIO::LLPumpIO(apr_pool_t* pool) :
+LLPumpIO::LLPumpIO(void) :
         mState(LLPumpIO::NORMAL),
         mRebuildPollset(false),
         mPollset(NULL),
         mPollsetClientID(0),
         mNextLock(0),
-        mPool(NULL),
-        mCurrentPool(NULL),
         mCurrentPoolReallocCount(0),
         mChainsMutex(NULL),
         mCallbackMutex(NULL),
@@ -185,21 +184,24 @@ LLPumpIO::LLPumpIO(apr_pool_t* pool) :
         mCurrentChain = mRunningChains.end();
 
         LLMemType m1(LLMemType::MTYPE_IO_PUMP);
-        initialize(pool);
+        initialize();
 }
 
 LLPumpIO::~LLPumpIO()
 {
         LLMemType m1(LLMemType::MTYPE_IO_PUMP);
-        cleanup();
-}
-
-bool LLPumpIO::prime(apr_pool_t* pool)
-{
-        LLMemType m1(LLMemType::MTYPE_IO_PUMP);
-        cleanup();
-        initialize(pool);
-        return ((pool == NULL) ? false : true);
+#if LL_THREADS_APR
+        if (mChainsMutex) apr_thread_mutex_destroy(mChainsMutex);
+        if (mCallbackMutex) apr_thread_mutex_destroy(mCallbackMutex);
+#endif
+        mChainsMutex = NULL;
+        mCallbackMutex = NULL;
+        if(mPollset)
+        {
+//              lldebugs << "cleaning up pollset" << llendl;
+                apr_pollset_destroy(mPollset);
+                mPollset = NULL;
+        }
 }
 
 bool LLPumpIO::addChain(const chain_t& chain, F32 timeout)
@@ -359,8 +361,7 @@ bool LLPumpIO::setConditional(LLIOPipe* pipe, const apr_pollfd_t* poll)
         {
                 // each fd needs a pool to work with, so if one was
                 // not specified, use this pool.
-                // *FIX: Should it always be this pool?
-                value.second.p = mPool;
+                value.second.p = (*mCurrentChain).mDescriptorsPool->operator()();
         }
         value.second.client_data = new S32(++mPollsetClientID);
         (*mCurrentChain).mDescriptors.push_back(value);
@@ -827,39 +828,15 @@ void LLPumpIO::control(LLPumpIO::EControl op)
         }
 }
 
-void LLPumpIO::initialize(apr_pool_t* pool)
+void LLPumpIO::initialize(void)
 {
         LLMemType m1(LLMemType::MTYPE_IO_PUMP);
-        if(!pool) return;
+        mPool.create();
 #if LL_THREADS_APR
         // SJB: Windows defaults to NESTED and OSX defaults to UNNESTED, so use UNNESTED explicitly.
-        apr_thread_mutex_create(&mChainsMutex, APR_THREAD_MUTEX_UNNESTED, pool);
-        apr_thread_mutex_create(&mCallbackMutex, APR_THREAD_MUTEX_UNNESTED, pool);
-#endif
-        mPool = pool;
-}
-
-void LLPumpIO::cleanup()
-{
-        LLMemType m1(LLMemType::MTYPE_IO_PUMP);
-#if LL_THREADS_APR
-        if(mChainsMutex) apr_thread_mutex_destroy(mChainsMutex);
-        if(mCallbackMutex) apr_thread_mutex_destroy(mCallbackMutex);
+        apr_thread_mutex_create(&mChainsMutex, APR_THREAD_MUTEX_UNNESTED, mPool());
+        apr_thread_mutex_create(&mCallbackMutex, APR_THREAD_MUTEX_UNNESTED, mPool());
 #endif
-        mChainsMutex = NULL;
-        mCallbackMutex = NULL;
-        if(mPollset)
-        {
-//              lldebugs << "cleaning up pollset" << llendl;
-                apr_pollset_destroy(mPollset);
-                mPollset = NULL;
-        }
-        if(mCurrentPool)
-        {
-                apr_pool_destroy(mCurrentPool);
-                mCurrentPool = NULL;
-        }
-        mPool = NULL;
 }
 
 void LLPumpIO::rebuildPollset()
@@ -887,21 +864,19 @@ void LLPumpIO::rebuildPollset()
                 if(mCurrentPool
                    && (0 == (++mCurrentPoolReallocCount % POLLSET_POOL_RECYCLE_COUNT)))
                 {
-                        apr_pool_destroy(mCurrentPool);
-                        mCurrentPool = NULL;
+                        mCurrentPool.destroy();
                         mCurrentPoolReallocCount = 0;
                 }
                 if(!mCurrentPool)
                 {
-                        apr_status_t status = apr_pool_create(&mCurrentPool, mPool);
-                        (void)ll_apr_warn_status(status);
+                        mCurrentPool.create(mPool);
                 }
 
                 // add all of the file descriptors
                 run_it = mRunningChains.begin();
                 LLChainInfo::conditionals_t::iterator fd_it;
                 LLChainInfo::conditionals_t::iterator fd_end;
-                apr_pollset_create(&mPollset, size, mCurrentPool, 0);
+                apr_pollset_create(&mPollset, size, mCurrentPool(), 0);
                 for(; run_it != run_end; ++run_it)
                 {
                         fd_it = (*run_it).mDescriptors.begin();
@@ -1159,7 +1134,8 @@ bool LLPumpIO::handleChainError(
 LLPumpIO::LLChainInfo::LLChainInfo() :
         mInit(false),
         mLock(0),
-        mEOS(false)
+        mEOS(false),
+        mDescriptorsPool(new AIAPRPool(LLThread::tldata().mRootPool))
 {
         LLMemType m1(LLMemType::MTYPE_IO_PUMP);
         mTimer.setTimerExpirySec(DEFAULT_CHAIN_EXPIRY_SECS);
diff --git a/linden/indra/llmessage/llpumpio.h b/linden/indra/llmessage/llpumpio.h
index fc0bfab..2666be0 100644
--- a/linden/indra/llmessage/llpumpio.h
+++ b/linden/indra/llmessage/llpumpio.h
@@ -36,11 +36,12 @@
 #define LL_LLPUMPIO_H
 
 #include <set>
+#include <boost/shared_ptr.hpp>
 #if LL_LINUX  // needed for PATH_MAX in APR.
 #include <sys/param.h>
 #endif
 
-#include "apr_pools.h"
+#include "aiaprpool.h"
 #include "llbuffer.h"
 #include "llframetimer.h"
 #include "lliopipe.h"
@@ -64,9 +65,8 @@ extern const F32 NEVER_CHAIN_EXPIRY_SECS;
  * <code>pump()</code> on a thread used for IO and call
  * <code>respond()</code> on a thread that is expected to do higher
  * level processing. You can call almost any other method from any
- * thread - see notes for each method for details. In order for the
- * threading abstraction to work, you need to call <code>prime()</code>
- * with a valid apr pool.
+ * thread - see notes for each method for details.
+ *
  * A pump instance manages much of the state for the pipe, including
  * the list of pipes in the chain, the channel for each element in the
  * chain, the buffer, and if any pipe has marked the stream or process
@@ -85,7 +85,7 @@ public:
         /**
          * @brief Constructor.
          */
-        LLPumpIO(apr_pool_t* pool);
+        LLPumpIO(void);
 
         /**
          * @brief Destructor.
@@ -93,17 +93,6 @@ public:
         ~LLPumpIO();
 
         /**
-         * @brief Prepare this pump for usage.
-         *
-         * If you fail to call this method prior to use, the pump will
-         * try to work, but will not come with any thread locking
-         * mechanisms.
-         * @param pool The apr pool to use.
-         * @return Returns true if the pump is primed.
-         */
-        bool prime(apr_pool_t* pool);
-
-        /**
          * @brief Typedef for having a chain of pipes.
          */
         typedef std::vector<LLIOPipe::ptr_t> chain_t;
@@ -374,6 +363,7 @@ protected:
                 typedef std::pair<LLIOPipe::ptr_t, apr_pollfd_t> pipe_conditional_t;
                 typedef std::vector<pipe_conditional_t> conditionals_t;
                 conditionals_t mDescriptors;
+                boost::shared_ptr<AIAPRPool> mDescriptorsPool;
         };
 
         // All the running chains & info
@@ -392,9 +382,9 @@ protected:
         callbacks_t mPendingCallbacks;
         callbacks_t mCallbacks;
 
-        // memory allocator for pollsets & mutexes.
-        apr_pool_t* mPool;
-        apr_pool_t* mCurrentPool;
+        // Memory pool for pollsets & mutexes.
+        AIAPRPool mPool;
+        AIAPRPool mCurrentPool;
         S32 mCurrentPoolReallocCount;
 
 #if LL_THREADS_APR
@@ -406,8 +396,7 @@ protected:
 #endif
 
 protected:
-        void initialize(apr_pool_t* pool);
-        void cleanup();
+        void initialize();
 
         /** 
          * @brief Given the internal state of the chains, rebuild the pollset
diff --git a/linden/indra/llmessage/llregionflags.h b/linden/indra/llmessage/llregionflags.h
index 2324785..70c3499 100644
--- a/linden/indra/llmessage/llregionflags.h
+++ b/linden/indra/llmessage/llregionflags.h
@@ -137,15 +137,6 @@ inline U32 unset_prelude_flags(U32 flags)
                         & ~(REGION_FLAGS_PRELUDE_SET | REGION_FLAGS_SUN_FIXED));
 }
 
-// estate constants. Need to match first few etries in indra.estate table.
-const U32 ESTATE_ALL = 0; // will not match in db, reserved key for logic
-const U32 ESTATE_MAINLAND = 1;
-const U32 ESTATE_ORIENTATION = 2;
-const U32 ESTATE_INTERNAL = 3;
-const U32 ESTATE_SHOWCASE = 4;
-const U32 ESTATE_TEEN = 5;
-const U32 ESTATE_LAST_LINDEN = 5; // last linden owned/managed estate
-
 // for EstateOwnerRequest, setaccess message
 const U32 ESTATE_ACCESS_ALLOWED_AGENTS  = 1 << 0;
 const U32 ESTATE_ACCESS_ALLOWED_GROUPS  = 1 << 1;
diff --git a/linden/indra/llmessage/llurlrequest.cpp b/linden/indra/llmessage/llurlrequest.cpp
index 46e976f..87f0116 100644
--- a/linden/indra/llmessage/llurlrequest.cpp
+++ b/linden/indra/llmessage/llurlrequest.cpp
@@ -45,6 +45,7 @@
 #include "llstring.h"
 #include "apr_env.h"
 #include "llapr.h"
+#include "llscopedvolatileaprpool.h"
 static const U32 HTTP_STATUS_PIPE_ERROR = 499;
 
 /**
@@ -161,27 +162,31 @@ void LLURLRequest::setCallback(LLURLRequestComplete* callback)
 // is called with use_proxy = FALSE
 void LLURLRequest::useProxy(bool use_proxy)
 {
-    static char *env_proxy;
+    static std::string env_proxy;
 
-    if (use_proxy && (env_proxy == NULL))
+    if (use_proxy && env_proxy.empty())
     {
-        apr_status_t status;
-        LLAPRPool pool;
-                status = apr_env_get(&env_proxy, "ALL_PROXY", pool.getAPRPool());
+                char* env_proxy_str;
+        LLScopedVolatileAPRPool scoped_pool;
+        apr_status_t status = apr_env_get(&env_proxy_str, "ALL_PROXY", scoped_pool);
         if (status != APR_SUCCESS)
         {
-                        status = apr_env_get(&env_proxy, "http_proxy", pool.getAPRPool());
+                        status = apr_env_get(&env_proxy_str, "http_proxy", scoped_pool);
         }
         if (status != APR_SUCCESS)
         {
-           use_proxy = FALSE;
+            use_proxy = false;
         }
+                else
+                {
+                        // env_proxy_str is stored in the scoped_pool, so we have to make a copy.
+                        env_proxy = env_proxy_str;
+                }
     }
 
+    lldebugs << "use_proxy = " << (use_proxy?'Y':'N') << ", env_proxy = \"" << env_proxy << "\"" << llendl;
 
-    lldebugs << "use_proxy = " << (use_proxy?'Y':'N') << ", env_proxy = " << (env_proxy ? env_proxy : "(null)") << llendl;
-
-    if (env_proxy && use_proxy)
+    if (use_proxy)
     {
                 mDetail->mCurlRequest->setoptString(CURLOPT_PROXY, env_proxy);
     }
diff --git a/linden/indra/llmessage/message.cpp b/linden/indra/llmessage/message.cpp
index 7e8aff1..53036bc 100644
--- a/linden/indra/llmessage/message.cpp
+++ b/linden/indra/llmessage/message.cpp
@@ -103,8 +103,10 @@ std::string get_shared_secret();
 class LLMessagePollInfo
 {
 public:
+        LLMessagePollInfo(void) : mPool(LLThread::tldata().mRootPool) { }
         apr_socket_t *mAPRSocketp;
         apr_pollfd_t mPollFD;
+        AIAPRPool mPool;
 };
 
 namespace
@@ -291,20 +293,13 @@ LLMessageSystem::LLMessageSystem(const std::string& filename, U32 port,
         }
 //      LL_DEBUGS("Messaging") <<  << "*** port: " << mPort << llendl;
 
-        //
-        // Create the data structure that we can poll on
-        //
-        if (!gAPRPoolp)
-        {
-                LL_ERRS("Messaging") << "No APR pool before message system initialization!" << llendl;
-                ll_init_apr();
-        }
+        mPollInfop = new LLMessagePollInfo;
+
         apr_socket_t *aprSocketp = NULL;
-        apr_os_sock_put(&aprSocketp, (apr_os_sock_t*)&mSocket, gAPRPoolp);
+        apr_os_sock_put(&aprSocketp, (apr_os_sock_t*)&mSocket, mPollInfop->mPool());
 
-        mPollInfop = new LLMessagePollInfo;
         mPollInfop->mAPRSocketp = aprSocketp;
-        mPollInfop->mPollFD.p = gAPRPoolp;
+        mPollInfop->mPollFD.p = mPollInfop->mPool();
         mPollInfop->mPollFD.desc_type = APR_POLL_SOCKET;
         mPollInfop->mPollFD.reqevents = APR_POLLIN;
         mPollInfop->mPollFD.rtnevents = 0;
diff --git a/linden/indra/llplugin/llpluginclassmedia.cpp b/linden/indra/llplugin/llpluginclassmedia.cpp
index 85241be..5a81c46 100755
--- a/linden/indra/llplugin/llpluginclassmedia.cpp
+++ b/linden/indra/llplugin/llpluginclassmedia.cpp
@@ -72,10 +72,10 @@ LLPluginClassMedia::~LLPluginClassMedia()
 }
 
 bool LLPluginClassMedia::init(const std::string &launcher_filename, const std::string &plugin_filename, bool debug)
-{       
-        LL_DEBUGS("Plugin") << "launcher: " << launcher_filename << LL_ENDL;
-        LL_DEBUGS("Plugin") << "plugin: " << plugin_filename << LL_ENDL;
-        
+{
+        LL_DEBUGS("PluginClassMedia") << "launcher: " << launcher_filename << LL_ENDL;
+        LL_DEBUGS("PluginClassMedia") << "plugin: " << plugin_filename << LL_ENDL;
+
         mPlugin = new LLPluginProcessParent(this);
         mPlugin->setSleepTime(mSleepTime);
         
@@ -198,7 +198,7 @@ void LLPluginClassMedia::idle(void)
                                 }
                                 else
                                 {
-                                        LL_WARNS("Plugin") << "Unable to pad texture width, padding size " << mPadding << "is not a multiple of pixel size " << mRequestedTextureDepth << LL_ENDL;
+                                        LL_WARNS("PluginClassMedia") << "Unable to pad texture width, padding size " << mPadding << "is not a multiple of pixel size " << mRequestedTextureDepth << LL_ENDL;
                                 }
                         }
                 }
@@ -256,11 +256,11 @@ void LLPluginClassMedia::idle(void)
                         message.setValueReal("background_b", mBackgroundColor.mV[VZ]);
                         message.setValueReal("background_a", mBackgroundColor.mV[VW]);
                         mPlugin->sendMessage(message);  // DO NOT just use sendMessage() here -- we want this to jump ahead of the queue.
-                        
-                        LL_DEBUGS("Plugin") << "Sending size_change" << LL_ENDL;
+
+                        LL_DEBUGS("PluginClassMedia") << "Sending size_change" << LL_ENDL;
                 }
         }
-        
+
         if(mPlugin && mPlugin->isRunning())
         {
                 // Send queued messages
@@ -777,7 +777,7 @@ void LLPluginClassMedia::receivePluginMessage(const LLPluginMessage &message)
                                         mDirtyRect.unionWith(newDirtyRect);
                                 }
 
-                                LL_DEBUGS("Plugin") << "adjusted incoming rect is: (" 
+                                LL_DEBUGS("PluginClassMedia") << "adjusted incoming rect is: ("
                                         << newDirtyRect.mLeft << ", "
                                         << newDirtyRect.mTop << ", "
                                         << newDirtyRect.mRight << ", "
@@ -841,9 +841,9 @@ void LLPluginClassMedia::receivePluginMessage(const LLPluginMessage &message)
                 else if(message_name == "media_status")
                 {
                         std::string status = message.getValue("status");
-                        
-                        LL_DEBUGS("Plugin") << "Status changed to: " << status << LL_ENDL;
-                        
+
+                        LL_DEBUGS("PluginClassMedia") << "Status changed to: " << status << LL_ENDL;
+
                         if(status == "loading")
                         {
                                 mStatus = LLPluginClassMediaOwner::MEDIA_LOADING;
@@ -933,7 +933,7 @@ void LLPluginClassMedia::receivePluginMessage(const LLPluginMessage &message)
                 }
                 else
                 {
-                        LL_WARNS("Plugin") << "Unknown " << message_name << " class message: " << message_name << LL_ENDL;
+                        LL_WARNS("PluginClassMedia") << "Unknown " << message_name << " class message: " << message_name << LL_ENDL;
                 }
         }
         else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER)
@@ -990,7 +990,7 @@ void LLPluginClassMedia::receivePluginMessage(const LLPluginMessage &message)
                 }
                 else
                 {
-                        LL_WARNS("Plugin") << "Unknown " << message_name << " class message: " << message_name << LL_ENDL;
+                        LL_WARNS("PluginClassMedia") << "Unknown " << message_name << " class message: " << message_name << LL_ENDL;
                 }
         }
         else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME)
@@ -1001,9 +1001,9 @@ void LLPluginClassMedia::receivePluginMessage(const LLPluginMessage &message)
 //              if(message_name == "message_name")
 //              {
 //              }
-//              else 
+//              else
                 {
-                        LL_WARNS("Plugin") << "Unknown " << message_name << " class message: " << message_name << LL_ENDL;
+                        LL_WARNS("PluginClassMedia") << "Unknown " << message_name << " class message: " << message_name << LL_ENDL;
                 }
         }
 
@@ -1230,6 +1230,6 @@ void LLPluginClassMedia::initializeUrlHistory(const LLSD& url_history)
         message.setValueLLSD("history", url_history);
         sendMessage(message);
 
-        LL_DEBUGS("Plugin") << "Sending history" << LL_ENDL;
+        LL_DEBUGS("PluginClassMedia") << "Sending history" << LL_ENDL;
 }
 
diff --git a/linden/indra/llplugin/llplugininstance.cpp b/linden/indra/llplugin/llplugininstance.cpp
index b822b9e..67457f2 100755
--- a/linden/indra/llplugin/llplugininstance.cpp
+++ b/linden/indra/llplugin/llplugininstance.cpp
@@ -36,8 +36,7 @@
 #include "linden_common.h"
 
 #include "llplugininstance.h"
-
-#include "llapr.h"
+#include "aiaprpool.h"
 
 /** Virtual destructor. */
 LLPluginInstanceMessageListener::~LLPluginInstanceMessageListener()
@@ -86,16 +85,16 @@ int LLPluginInstance::load(std::string &plugin_file)
         
         int result = apr_dso_load(&mDSOHandle,
                                           plugin_file.c_str(),
-                                          gAPRPoolp);
+                                          AIAPRRootPool::get()());
         if(result != APR_SUCCESS)
         {
                 char buf[1024];
                 apr_dso_error(mDSOHandle, buf, sizeof(buf));
 
-                LL_WARNS("Plugin") << "apr_dso_load of " << plugin_file << " failed with error " << result << " , additional info string: " << buf << LL_ENDL;
-                
+                LL_WARNS("PluginInstance") << "apr_dso_load of " << plugin_file << " failed with error " << result << " , additional info string: " << buf << LL_ENDL;
+
         }
-        
+
         if(result == APR_SUCCESS)
         {
                 result = apr_dso_sym((apr_dso_handle_sym_t*)&init_function,
@@ -104,20 +103,20 @@ int LLPluginInstance::load(std::string &plugin_file)
 
                 if(result != APR_SUCCESS)
                 {
-                        LL_WARNS("Plugin") << "apr_dso_sym failed with error " << result << LL_ENDL;
+                        LL_WARNS("PluginInstance") << "apr_dso_sym failed with error " << result << LL_ENDL;
                 }
         }
-        
+
         if(result == APR_SUCCESS)
         {
                 result = init_function(staticReceiveMessage, (void*)this, &mPluginSendMessageFunction, &mPluginUserData);
 
                 if(result != APR_SUCCESS)
                 {
-                        LL_WARNS("Plugin") << "call to init function failed with error " << result << LL_ENDL;
+                        LL_WARNS("PluginInstance") << "call to init function failed with error " << result << LL_ENDL;
                 }
         }
-        
+
         return (int)result;
 }
 
@@ -130,12 +129,12 @@ void LLPluginInstance::sendMessage(const std::string &message)
 {
         if(mPluginSendMessageFunction)
         {
-                LL_DEBUGS("Plugin") << "sending message to plugin: \"" << message << "\"" << LL_ENDL;
+                LL_DEBUGS("PluginInstance") << "sending message to plugin: \"" << message << "\"" << LL_ENDL;
                 mPluginSendMessageFunction(message.c_str(), &mPluginUserData);
         }
         else
         {
-                LL_WARNS("Plugin") << "dropping message: \"" << message << "\"" << LL_ENDL;
+                LL_WARNS("PluginInstance") << "dropping message: \"" << message << "\"" << LL_ENDL;
         }
 }
 
@@ -165,11 +164,11 @@ void LLPluginInstance::receiveMessage(const char *message_string)
 {
         if(mOwner)
         {
-                LL_DEBUGS("Plugin") << "processing incoming message: \"" << message_string << "\"" << LL_ENDL;          
+                LL_DEBUGS("PluginInstance") << "processing incoming message: \"" << message_string << "\"" << LL_ENDL;
                 mOwner->receivePluginMessage(message_string);
         }
         else
         {
-                LL_WARNS("Plugin") << "dropping incoming message: \"" << message_string << "\"" << LL_ENDL;             
-        }       
+                LL_WARNS("PluginInstance") << "dropping incoming message: \"" << message_string << "\"" << LL_ENDL;
+        }
 }
diff --git a/linden/indra/llplugin/llpluginmessagepipe.cpp b/linden/indra/llplugin/llpluginmessagepipe.cpp
index 8168b32..ac3a902 100755
--- a/linden/indra/llplugin/llpluginmessagepipe.cpp
+++ b/linden/indra/llplugin/llpluginmessagepipe.cpp
@@ -82,10 +82,10 @@ bool LLPluginMessagePipeOwner::writeMessageRaw(const std::string &message)
         }
         else
         {
-                LL_WARNS("Plugin") << "dropping message: " << message << LL_ENDL;
+                LL_WARNS("PluginPipe") << "dropping message: " << message << LL_ENDL;
                 result = false;
         }
-        
+
         return result;
 }
 
@@ -99,8 +99,6 @@ void LLPluginMessagePipeOwner::killMessagePipe(void)
 }
 
 LLPluginMessagePipe::LLPluginMessagePipe(LLPluginMessagePipeOwner *owner, LLSocket::ptr_t socket):
-        mInputMutex(gAPRPoolp),
-        mOutputMutex(gAPRPoolp),
         mOwner(owner),
         mSocket(socket)
 {
@@ -179,18 +177,18 @@ bool LLPluginMessagePipe::pumpOutput()
                 {
                         // write any outgoing messages
                         size = (apr_size_t)mOutput.size();
-                        
+
                         setSocketTimeout(0);
-                        
-//                      LL_INFOS("Plugin") << "before apr_socket_send, size = " << size << LL_ENDL;
+
+//                      LL_INFOS("PluginPipe") << "before apr_socket_send, size = " << size << LL_ENDL;
 
                         status = apr_socket_send(
                                         mSocket->getSocket(),
                                         (const char*)mOutput.data(),
                                         &size);
 
-//                      LL_INFOS("Plugin") << "after apr_socket_send, size = " << size << LL_ENDL;
-                        
+//                      LL_INFOS("PluginPipe") << "after apr_socket_send, size = " << size << LL_ENDL;
+
                         if(status == APR_SUCCESS)
                         {
                                 // success
@@ -277,15 +275,15 @@ bool LLPluginMessagePipe::pumpInput(F64 timeout)
                         {
                                 size = request_size;
 
-//                              LL_INFOS("Plugin") << "before apr_socket_recv, size = " << size << LL_ENDL;
+//                              LL_INFOS("PluginPipe") << "before apr_socket_recv, size = " << size << LL_ENDL;
 
                                 status = apr_socket_recv(
-                                                mSocket->getSocket(), 
-                                                input_buf, 
+                                                mSocket->getSocket(),
+                                                input_buf,
                                                 &size);
 
-//                              LL_INFOS("Plugin") << "after apr_socket_recv, size = " << size << LL_ENDL;
-                                
+//                              LL_INFOS("PluginPipe") << "after apr_socket_recv, size = " << size << LL_ENDL;
+
                                 if(size > 0)
                                 {
                                         LLMutexLock lock(&mInputMutex);
@@ -379,7 +377,7 @@ void LLPluginMessagePipe::processInput(void)
                 }
                 else
                 {
-                        LL_WARNS("Plugin") << "!mOwner" << LL_ENDL;
+                        LL_WARNS("PluginPipe") << "!mOwner" << LL_ENDL;
                 }
         }
         mInputMutex.unlock();
diff --git a/linden/indra/llplugin/llpluginprocesschild.cpp b/linden/indra/llplugin/llpluginprocesschild.cpp
index 8dbf2b3..a1291c0 100755
--- a/linden/indra/llplugin/llpluginprocesschild.cpp
+++ b/linden/indra/llplugin/llpluginprocesschild.cpp
@@ -47,7 +47,7 @@ LLPluginProcessChild::LLPluginProcessChild()
 {
         mState = STATE_UNINITIALIZED;
         mInstance = NULL;
-        mSocket = LLSocket::create(gAPRPoolp, LLSocket::STREAM_TCP);
+        mSocket = LLSocket::create(LLSocket::STREAM_TCP);
         mSleepTime = PLUGIN_IDLE_SECONDS;       // default: send idle messages at 100Hz
         mCPUElapsed = 0.0f;
         mBlockingRequest = false;
@@ -94,18 +94,18 @@ void LLPluginProcessChild::idle(void)
                 }
                 else if(mSocketError != APR_SUCCESS)
                 {
-                        LL_INFOS("Plugin") << "message pipe is in error state (" << mSocketError << "), moving to STATE_ERROR"<< LL_ENDL;
+                        LL_INFOS("PluginChild") << "message pipe is in error state (" << mSocketError << "), moving to STATE_ERROR"<< LL_ENDL;
                         setState(STATE_ERROR);
-                }       
+                }
 
                 if((mState > STATE_INITIALIZED) && (mMessagePipe == NULL))
                 {
                         // The pipe has been closed -- we're done.
                         // TODO: This could be slightly more subtle, but I'm not sure it needs to be.
-                        LL_INFOS("Plugin") << "message pipe went away, moving to STATE_ERROR"<< LL_ENDL;
+                        LL_INFOS("PluginChild") << "message pipe went away, moving to STATE_ERROR"<< LL_ENDL;
                         setState(STATE_ERROR);
                 }
-        
+
                 // If a state needs to go directly to another state (as a performance enhancement), it can set idle_again to true after calling setState().
                 // USE THIS CAREFULLY, since it can starve other code.  Specifically make sure there's no way to get into a closed cycle and never return.
                 // When in doubt, don't do it.
@@ -291,17 +291,17 @@ void LLPluginProcessChild::sendMessageToPlugin(const LLPluginMessage &message)
         if (mInstance)
         {
                 std::string buffer = message.generate();
-                
-                LL_DEBUGS("Plugin") << "Sending to plugin: " << buffer << LL_ENDL;
+
+                LL_DEBUGS("PluginChild") << "Sending to plugin: " << buffer << LL_ENDL;
                 LLTimer elapsed;
-                
+
                 mInstance->sendMessage(buffer);
                 
                 mCPUElapsed += elapsed.getElapsedTimeF64();
         }
         else
         {
-                LL_WARNS("Plugin") << "mInstance == NULL" << LL_ENDL;
+                LL_WARNS("PluginChild") << "mInstance == NULL" << LL_ENDL;
         }
 }
 
@@ -309,7 +309,7 @@ void LLPluginProcessChild::sendMessageToParent(const LLPluginMessage &message)
 {
         std::string buffer = message.generate();
 
-        LL_DEBUGS("Plugin") << "Sending to parent: " << buffer << LL_ENDL;
+        LL_DEBUGS("PluginChild") << "Sending to parent: " << buffer << LL_ENDL;
 
         writeMessageRaw(buffer);
 }
@@ -318,7 +318,7 @@ void LLPluginProcessChild::receiveMessageRaw(const std::string &message)
 {
         // Incoming message from the TCP Socket
 
-        LL_DEBUGS("Plugin") << "Received from parent: " << message << LL_ENDL;
+        LL_DEBUGS("PluginChild") << "Received from parent: " << message << LL_ENDL;
 
         // Decode this message
         LLPluginMessage parsed;
@@ -365,7 +365,7 @@ void LLPluginProcessChild::receiveMessageRaw(const std::string &message)
                                 if(iter != mSharedMemoryRegions.end())
                                 {
                                         // Need to remove the old region first
-                                        LL_WARNS("Plugin") << "Adding a duplicate shared memory segment!" << LL_ENDL;
+                                        LL_WARNS("PluginChild") << "Adding a duplicate shared memory segment!" << LL_ENDL;
                                 }
                                 else
                                 {
@@ -392,7 +392,7 @@ void LLPluginProcessChild::receiveMessageRaw(const std::string &message)
                                         }
                                         else
                                         {
-                                                LL_WARNS("Plugin") << "Couldn't create a shared memory segment!" << LL_ENDL;
+                                                LL_WARNS("PluginChild") << "Couldn't create a shared memory segment!" << LL_ENDL;
                                                 delete region;
                                         }
                                 }
@@ -411,7 +411,7 @@ void LLPluginProcessChild::receiveMessageRaw(const std::string &message)
                                 }
                                 else
                                 {
-                                        LL_WARNS("Plugin") << "shm_remove for unknown memory segment!" << LL_ENDL;
+                                        LL_WARNS("PluginChild") << "shm_remove for unknown memory segment!" << LL_ENDL;
                                 }
                         }
                         else if(message_name == "sleep_time")
@@ -421,12 +421,12 @@ void LLPluginProcessChild::receiveMessageRaw(const std::string &message)
                         else if(message_name == "crash")
                         {
                                 // Crash the plugin
-                                LL_ERRS("Plugin") << "Plugin crash requested." << LL_ENDL;
+                                LL_ERRS("PluginChild") << "Plugin crash requested." << LL_ENDL;
                         }
                         else if(message_name == "hang")
                         {
                                 // Hang the plugin
-                                LL_WARNS("Plugin") << "Plugin hang requested." << LL_ENDL;
+                                LL_WARNS("PluginChild") << "Plugin hang requested." << LL_ENDL;
                                 while(1)
                                 {
                                         // wheeeeeeeee......
@@ -434,7 +434,7 @@ void LLPluginProcessChild::receiveMessageRaw(const std::string &message)
                         }
                         else
                         {
-                                LL_WARNS("Plugin") << "Unknown internal message from parent: " << message_name << LL_ENDL;
+                                LL_WARNS("PluginChild") << "Unknown internal message from parent: " << message_name << LL_ENDL;
                         }
                 }
         }
@@ -449,17 +449,17 @@ void LLPluginProcessChild::receiveMessageRaw(const std::string &message)
         }
 }
 
-/* virtual */ 
+/* virtual */
 void LLPluginProcessChild::receivePluginMessage(const std::string &message)
 {
-        LL_DEBUGS("Plugin") << "Received from plugin: " << message << LL_ENDL;
-        
+        LL_DEBUGS("PluginChild") << "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;
+                //
+                LL_ERRS("PluginChild") << "Can't send a message while already waiting on a blocking request -- aborting!" << LL_ENDL;
         }
-        
+
         // Incoming message from the plugin instance
         bool passMessage = true;
 
@@ -523,18 +523,18 @@ void LLPluginProcessChild::receivePluginMessage(const std::string &message)
                                 }
                                 else
                                 {
-                                        LL_WARNS("Plugin") << "shm_remove_response for unknown memory segment!" << LL_ENDL;
+                                        LL_WARNS("PluginChild") << "shm_remove_response for unknown memory segment!" << LL_ENDL;
                                 }
                         }
                 }
         }
-        
+
         if(passMessage)
         {
-                LL_DEBUGS("Plugin") << "Passing through to parent: " << message << LL_ENDL;
+                LL_DEBUGS("PluginChild") << "Passing through to parent: " << message << LL_ENDL;
                 writeMessageRaw(message);
         }
-        
+
         while(mBlockingRequest)
         {
                 // The plugin wants to block and wait for a response to this message.
@@ -552,8 +552,8 @@ void LLPluginProcessChild::receivePluginMessage(const std::string &message)
 
 void LLPluginProcessChild::setState(EState state)
 {
-        LL_DEBUGS("Plugin") << "setting state to " << state << LL_ENDL;
-        mState = state; 
+        LL_DEBUGS("PluginChild") << "setting state to " << state << LL_ENDL;
+        mState = state;
 };
 
 void LLPluginProcessChild::deliverQueuedMessages()
diff --git a/linden/indra/llplugin/llpluginprocessparent.cpp b/linden/indra/llplugin/llpluginprocessparent.cpp
index 8fd18ef..5a66279 100755
--- a/linden/indra/llplugin/llpluginprocessparent.cpp
+++ b/linden/indra/llplugin/llpluginprocessparent.cpp
@@ -49,6 +49,7 @@ LLPluginProcessParentOwner::~LLPluginProcessParentOwner()
 
 bool LLPluginProcessParent::sUseReadThread = false;
 apr_pollset_t *LLPluginProcessParent::sPollSet = NULL;
+AIAPRPool LLPluginProcessParent::sPollSetPool;
 bool LLPluginProcessParent::sPollsetNeedsRebuild = false;
 LLMutex *LLPluginProcessParent::sInstancesMutex;
 std::list<LLPluginProcessParent*> LLPluginProcessParent::sInstances;
@@ -59,7 +60,7 @@ class LLPluginProcessParentPollThread: public LLThread
 {
 public:
         LLPluginProcessParentPollThread() :
-                LLThread("LLPluginProcessParentPollThread", gAPRPoolp)
+                LLThread("LLPluginProcessParentPollThread")
         {
         }
 protected:
@@ -84,12 +85,11 @@ protected:
 
 };
 
-LLPluginProcessParent::LLPluginProcessParent(LLPluginProcessParentOwner *owner):
-        mIncomingQueueMutex(gAPRPoolp)
+LLPluginProcessParent::LLPluginProcessParent(LLPluginProcessParentOwner *owner)
 {
         if(!sInstancesMutex)
         {
-                sInstancesMutex = new LLMutex(gAPRPoolp);
+                sInstancesMutex = new LLMutex;
         }
         
         mOwner = owner;
@@ -102,6 +102,7 @@ LLPluginProcessParent::LLPluginProcessParent(LLPluginProcessParentOwner *owner):
         mBlocked = false;
         mPolledInput = false;
         mPollFD.client_data = NULL;
+        mPollFDPool.create();
 
         mPluginLaunchTimeout = 60.0f;
         mPluginLockupTimeout = 15.0f;
@@ -119,7 +120,7 @@ LLPluginProcessParent::LLPluginProcessParent(LLPluginProcessParentOwner *owner):
 
 LLPluginProcessParent::~LLPluginProcessParent()
 {
-        LL_DEBUGS("Plugin") << "destructor" << LL_ENDL;
+        LL_DEBUGS("PluginParent") << "destructor" << LL_ENDL;
 
         // Remove from the global list before beginning destruction.
         {
@@ -177,44 +178,28 @@ void LLPluginProcessParent::init(const std::string &launcher_filename, const std
 bool LLPluginProcessParent::accept()
 {
         bool result = false;
-        
         apr_status_t status = APR_EGENERAL;
-        apr_socket_t *new_socket = NULL;
-        
-        status = apr_socket_accept(
-                &new_socket,
-                mListenSocket->getSocket(),
-                gAPRPoolp);
 
+        mSocket = LLSocket::create(status, mListenSocket);
         
         if(status == APR_SUCCESS)
         {
 //              llinfos << "SUCCESS" << llendl;
                 // Success.  Create a message pipe on the new socket
-
-                // we MUST create a new pool for the LLSocket, since it will take ownership of it and delete it in its destructor!
-                apr_pool_t* new_pool = NULL;
-                status = apr_pool_create(&new_pool, gAPRPoolp);
-
-                mSocket = LLSocket::create(new_socket, new_pool);
                 new LLPluginMessagePipe(this, mSocket);
 
                 result = true;
         }
-        else if(APR_STATUS_IS_EAGAIN(status))
-        {
-//              llinfos << "EAGAIN" << llendl;
-
-                // No incoming connections.  This is not an error.
-                status = APR_SUCCESS;
-        }
         else
         {
-//              llinfos << "Error:" << llendl;
-                ll_apr_warn_status(status);
-                
-                // Some other error.
-                errorState();
+                mSocket.reset();
+                // EAGAIN means "No incoming connections". This is not an error.
+                if (!APR_STATUS_IS_EAGAIN(status))
+                {
+                        // Some other error.
+                        ll_apr_warn_status(status);
+                        errorState();
+                }
         }
         
         return result;  
@@ -264,10 +249,10 @@ void LLPluginProcessParent::idle(void)
                         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;
+                                LL_WARNS("PluginParent") << "Socket hit an error state (" << mSocketError << ")" << LL_ENDL;
                                 errorState();
                         }
-                }       
+                }
                 
                 // If a state needs to go directly to another state (as a performance enhancement), it can set idle_again to true after calling setState().
                 // USE THIS CAREFULLY, since it can starve other code.  Specifically make sure there's no way to get into a closed cycle and never return.
@@ -283,7 +268,7 @@ void LLPluginProcessParent::idle(void)
         
                                 apr_status_t status = APR_SUCCESS;
                                 apr_sockaddr_t* addr = NULL;
-                                mListenSocket = LLSocket::create(gAPRPoolp, LLSocket::STREAM_TCP);
+                                mListenSocket = LLSocket::create(LLSocket::STREAM_TCP);
                                 mBoundPort = 0;
                                 
                                 // This code is based on parts of LLSocket::create() in lliosocket.cpp.
@@ -294,7 +279,7 @@ void LLPluginProcessParent::idle(void)
                                         APR_INET,
                                         0,      // port 0 = ephemeral ("find me a port")
                                         0,
-                                        gAPRPoolp);
+                                        AIAPRRootPool::get()());
                                         
                                 if(ll_apr_warn_status(status))
                                 {
@@ -327,15 +312,15 @@ void LLPluginProcessParent::idle(void)
 
                                         if(mBoundPort == 0)
                                         {
-                                                LL_WARNS("Plugin") << "Bound port number unknown, bailing out." << LL_ENDL;
-                                                
+                                                LL_WARNS("PluginParent") << "Bound port number unknown, bailing out." << LL_ENDL;
+
                                                 killSockets();
                                                 errorState();
                                                 break;
                                         }
                                 }
-                                
-                                LL_DEBUGS("Plugin") << "Bound tcp socket to port: " << addr->port << LL_ENDL;
+
+                                LL_DEBUGS("PluginParent") << "Bound tcp socket to port: " << addr->port << LL_ENDL;
 
                                 // Make the listen socket non-blocking
                                 status = apr_socket_opt_set(mListenSocket->getSocket(), APR_SO_NONBLOCK, 1);
@@ -458,8 +443,8 @@ void LLPluginProcessParent::idle(void)
                         break;
 
                         case STATE_HELLO:
-                                LL_DEBUGS("Plugin") << "received hello message" << LL_ENDL;
-                                
+                                LL_DEBUGS("PluginParent") << "received hello message" << LL_ENDL;
+
                                 // Send the message to load the plugin
                                 {
                                         LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "load_plugin");
@@ -492,7 +477,7 @@ void LLPluginProcessParent::idle(void)
                                 }
                                 else if(pluginLockedUp())
                                 {
-                                        LL_WARNS("Plugin") << "timeout in exiting state, bailing out" << LL_ENDL;
+                                        LL_WARNS("PluginParent") << "timeout in exiting state, bailing out" << LL_ENDL;
                                         errorState();
                                 }
                         break;
@@ -589,11 +574,11 @@ void LLPluginProcessParent::sendMessage(const LLPluginMessage &message)
                 // 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;        
+        LL_DEBUGS("PluginParent") << "Sending: " << buffer << LL_ENDL;
         writeMessageRaw(buffer);
-        
+
         // Try to send message immediately.
         if(mMessagePipe)
         {
@@ -617,7 +602,8 @@ void LLPluginProcessParent::setMessagePipe(LLPluginMessagePipe *message_pipe)
         if(message_pipe != NULL)
         {
                 // Set up the apr_pollfd_t
-                mPollFD.p = gAPRPoolp;
+
+                mPollFD.p = mPollFDPool();
                 mPollFD.desc_type = APR_POLL_SOCKET;
                 mPollFD.reqevents = APR_POLLIN|APR_POLLERR|APR_POLLHUP;
                 mPollFD.rtnevents = 0;
@@ -664,6 +650,7 @@ void LLPluginProcessParent::updatePollset()
                 // delete the existing pollset.
                 apr_pollset_destroy(sPollSet);
                 sPollSet = NULL;
+                sPollSetPool.destroy();
         }
         
         std::list<LLPluginProcessParent*>::iterator iter;
@@ -686,12 +673,14 @@ void LLPluginProcessParent::updatePollset()
                 {
 #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);
+                        sPollSetPool.create();  
+                        apr_status_t status = apr_pollset_create(&sPollSet, count, sPollSetPool(), APR_POLLSET_NOCOPY);
                         if(status != APR_SUCCESS)
                         {
 #endif // APR_POLLSET_NOCOPY
                                 LL_WARNS("PluginPoll") << "Couldn't create pollset.  Falling back to non-pollset mode." << LL_ENDL;
                                 sPollSet = NULL;
+                                sPollSetPool.destroy();
 #ifdef APR_POLLSET_NOCOPY
                         }
                         else
@@ -851,8 +840,8 @@ void LLPluginProcessParent::servicePoll()
 
 void LLPluginProcessParent::receiveMessageRaw(const std::string &message)
 {
-        LL_DEBUGS("Plugin") << "Received: " << message << LL_ENDL;
-        
+        LL_DEBUGS("PluginParent") << "Received: " << message << LL_ENDL;
+
         LLPluginMessage parsed;
         if(parsed.parse(message) != -1)
         {
@@ -918,19 +907,19 @@ void LLPluginProcessParent::receiveMessage(const LLPluginMessage &message)
                         }
                         else
                         {
-                                LL_WARNS("Plugin") << "received hello message in wrong state -- bailing out" << LL_ENDL;
+                                LL_WARNS("PluginParent") << "received hello message in wrong state -- bailing out" << LL_ENDL;
                                 errorState();
                         }
-                        
+
                 }
                 else if(message_name == "load_plugin_response")
                 {
                         if(mState == STATE_LOADING)
                         {
-                                // Plugin has been loaded. 
-                                
+                                // Plugin has been loaded.
+
                                 mPluginVersionString = message.getValue("plugin_version");
-                                LL_INFOS("Plugin") << "plugin version string: " << mPluginVersionString << LL_ENDL;
+                                LL_INFOS("PluginParent") << "plugin version string: " << mPluginVersionString << LL_ENDL;
 
                                 // Check which message classes/versions the plugin supports.
                                 // TODO: check against current versions
@@ -939,9 +928,9 @@ void LLPluginProcessParent::receiveMessage(const LLPluginMessage &message)
                                 LLSD::map_iterator iter;
                                 for(iter = mMessageClassVersions.beginMap(); iter != mMessageClassVersions.endMap(); iter++)
                                 {
-                                        LL_INFOS("Plugin") << "message class: " << iter->first << " -> version: " << iter->second.asString() << LL_ENDL;
+                                        LL_INFOS("PluginParent") << "message class: " << iter->first << " -> version: " << iter->second.asString() << LL_ENDL;
                                 }
-                                
+
                                 // Send initial sleep time
                                 setSleepTime(mSleepTime, true);                 
 
@@ -949,7 +938,7 @@ void LLPluginProcessParent::receiveMessage(const LLPluginMessage &message)
                         }
                         else
                         {
-                                LL_WARNS("Plugin") << "received load_plugin_response message in wrong state -- bailing out" << LL_ENDL;
+                                LL_WARNS("PluginParent") << "received load_plugin_response message in wrong state -- bailing out" << LL_ENDL;
                                 errorState();
                         }
                 }
@@ -960,8 +949,8 @@ void LLPluginProcessParent::receiveMessage(const LLPluginMessage &message)
 
                         mCPUUsage = message.getValueReal("cpu_usage");
 
-                        LL_DEBUGS("Plugin") << "cpu usage reported as " << mCPUUsage << LL_ENDL;
-                        
+                        LL_DEBUGS("PluginSpam") << "cpu usage reported as " << mCPUUsage << LL_ENDL;
+
                 }
                 else if(message_name == "shm_add_response")
                 {
@@ -983,7 +972,7 @@ void LLPluginProcessParent::receiveMessage(const LLPluginMessage &message)
                 }
                 else
                 {
-                        LL_WARNS("Plugin") << "Unknown internal message from child: " << message_name << LL_ENDL;
+                        LL_WARNS("PluginParent") << "Unknown internal message from child: " << message_name << LL_ENDL;
                 }
         }
         else
@@ -1015,7 +1004,7 @@ std::string LLPluginProcessParent::addSharedMemory(size_t size)
         }
         else
         {
-                LL_WARNS("Plugin") << "Couldn't create a shared memory segment!" << LL_ENDL;
+                LL_WARNS("PluginParent") << "Couldn't create a shared memory segment!" << LL_ENDL;
 
                 // Don't leak
                 delete region;
@@ -1037,7 +1026,7 @@ void LLPluginProcessParent::removeSharedMemory(const std::string &name)
         }
         else
         {
-                LL_WARNS("Plugin") << "Request to remove an unknown shared memory segment." << LL_ENDL;
+                LL_WARNS("PluginParent") << "Request to remove an unknown shared memory segment." << LL_ENDL;
         }
 }
 size_t LLPluginProcessParent::getSharedMemorySize(const std::string &name)
@@ -1084,25 +1073,25 @@ std::string LLPluginProcessParent::getPluginVersion(void)
 
 void LLPluginProcessParent::setState(EState state)
 {
-        LL_DEBUGS("Plugin") << "setting state to " << stateToString(state) << LL_ENDL;
-        mState = state; 
+        LL_DEBUGS("PluginParent") << "setting state to " << stateToString(state) << LL_ENDL;
+        mState = state;
 };
 
 bool LLPluginProcessParent::pluginLockedUpOrQuit()
 {
         bool result = false;
-        
+
         if(!mProcess.isRunning())
         {
-                LL_WARNS("Plugin") << "child exited" << LL_ENDL;
+                LL_WARNS("PluginParent") << "child exited" << LL_ENDL;
                 result = true;
         }
         else if(pluginLockedUp())
         {
-                LL_WARNS("Plugin") << "timeout" << LL_ENDL;
+                LL_WARNS("PluginParent") << "timeout" << LL_ENDL;
                 result = true;
         }
-        
+
         return result;
 }
 
diff --git a/linden/indra/llplugin/llpluginprocessparent.h b/linden/indra/llplugin/llpluginprocessparent.h
index 95f5f70..bba3643 100755
--- a/linden/indra/llplugin/llpluginprocessparent.h
+++ b/linden/indra/llplugin/llpluginprocessparent.h
@@ -186,7 +186,9 @@ private:
 
         static bool sUseReadThread;
         apr_pollfd_t mPollFD;
+        AIAPRPool mPollFDPool;
         static apr_pollset_t *sPollSet;
+    static AIAPRPool sPollSetPool;
         static bool sPollsetNeedsRebuild;
         static LLMutex *sInstancesMutex;
         static std::list<LLPluginProcessParent*> sInstances;
diff --git a/linden/indra/llplugin/llpluginsharedmemory.cpp b/linden/indra/llplugin/llpluginsharedmemory.cpp
index e8a411a..6becb8d 100755
--- a/linden/indra/llplugin/llpluginsharedmemory.cpp
+++ b/linden/indra/llplugin/llpluginsharedmemory.cpp
@@ -84,6 +84,8 @@
         #include <sys/mman.h>
         #include <errno.h>
 #elif USE_WIN32_SHARED_MEMORY
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
 #include <windows.h>
 #endif // USE_APR_SHARED_MEMORY
 
@@ -201,7 +203,8 @@ bool LLPluginSharedMemory::create(size_t size)
         mName += createName();
         mSize = size;
         
-        apr_status_t status = apr_shm_create( &(mImpl->mAprSharedMemory), mSize, mName.c_str(), gAPRPoolp );
+        mPool.create();
+        apr_status_t status = apr_shm_create( &(mImpl->mAprSharedMemory), mSize, mName.c_str(), mPool());
         
         if(ll_apr_warn_status(status))
         {
@@ -224,7 +227,7 @@ bool LLPluginSharedMemory::destroy(void)
                 }
                 mImpl->mAprSharedMemory = NULL;
         }
-        
+        mPool.destroy();
         return true;
 }
 
@@ -233,7 +236,8 @@ bool LLPluginSharedMemory::attach(const std::string &name, size_t size)
         mName = name;
         mSize = size;
         
-        apr_status_t status = apr_shm_attach( &(mImpl->mAprSharedMemory), mName.c_str(), gAPRPoolp );
+        mPool.create();
+        apr_status_t status = apr_shm_attach( &(mImpl->mAprSharedMemory), mName.c_str(), mPool() );
         
         if(ll_apr_warn_status(status))
         {
@@ -255,6 +259,7 @@ bool LLPluginSharedMemory::detach(void)
                 }
                 mImpl->mAprSharedMemory = NULL;
         }
+        mPool.destroy();
         
         return true;
 }
diff --git a/linden/indra/llplugin/llpluginsharedmemory.h b/linden/indra/llplugin/llpluginsharedmemory.h
index 081d311..669a3e4 100755
--- a/linden/indra/llplugin/llpluginsharedmemory.h
+++ b/linden/indra/llplugin/llpluginsharedmemory.h
@@ -35,6 +35,8 @@
 #ifndef LL_LLPLUGINSHAREDMEMORY_H
 #define LL_LLPLUGINSHAREDMEMORY_H
 
+#include "aiaprpool.h"
+
 class LLPluginSharedMemoryPlatformImpl;
 
 /**
@@ -115,6 +117,7 @@ private:
         bool close(void);
         bool unlink(void);
         
+        AIAPRPool mPool;
         std::string mName;
         size_t mSize;
         void *mMappedAddress;
diff --git a/linden/indra/llplugin/slplugin/slplugin.cpp b/linden/indra/llplugin/slplugin/slplugin.cpp
index 64c087b..878577b 100755
--- a/linden/indra/llplugin/slplugin/slplugin.cpp
+++ b/linden/indra/llplugin/slplugin/slplugin.cpp
@@ -78,6 +78,8 @@ static void crash_handler(int sig)
 #endif
 
 #if LL_WINDOWS
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
 #include <windows.h>
 ////////////////////////////////////////////////////////////////////////////////
 //      Our exception handler - will probably just exit and the host application
@@ -183,8 +185,6 @@ int APIENTRY WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdL
 int main(int argc, char **argv)
 #endif
 {
-        ll_init_apr();
-
         // Set up llerror logging
         {
                 LLError::initForApplication(".");
@@ -400,8 +400,6 @@ int main(int argc, char **argv)
 
         delete plugin;
 
-        ll_cleanup_apr();
-
         return 0;
 }
 
diff --git a/linden/indra/llvfs/llpidlock.h b/linden/indra/llvfs/llpidlock.h
index efcfd91..6103599 100755
--- a/linden/indra/llvfs/llpidlock.h
+++ b/linden/indra/llvfs/llpidlock.h
@@ -39,6 +39,8 @@ class LLFrameTimer;
 
 #if LL_WINDOWS  //For windows platform.
 
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
 #include <windows.h>
 
 #else   //Everyone Else
diff --git a/linden/indra/llvfs/llvfs.cpp b/linden/indra/llvfs/llvfs.cpp
index dea8c9c..654dfa1 100644
--- a/linden/indra/llvfs/llvfs.cpp
+++ b/linden/indra/llvfs/llvfs.cpp
@@ -237,7 +237,7 @@ const S32 LLVFSFileBlock::SERIAL_SIZE = 34;
 LLVFS::LLVFS(const std::string& index_filename, const std::string& data_filename, const BOOL read_only, const U32 presize, const BOOL remove_after_crash)
 :       mRemoveAfterCrash(remove_after_crash)
 {
-        mDataMutex = new LLMutex(0);
+        mDataMutex = new LLMutex;
 
         S32 i;
         for (i = 0; i < VFSLOCK_COUNT; i++)
diff --git a/linden/indra/llwindow/GL/glh_extensions.h b/linden/indra/llwindow/GL/glh_extensions.h
index b936b5d..5b149c9 100644
--- a/linden/indra/llwindow/GL/glh_extensions.h
+++ b/linden/indra/llwindow/GL/glh_extensions.h
@@ -17,6 +17,8 @@
 #include <stdio.h>
 
 #ifdef _WIN32
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
 # include <windows.h>
 #endif
 
diff --git a/linden/indra/media_plugins/CMakeLists.txt b/linden/indra/media_plugins/CMakeLists.txt
index a4c6b18..7c224b4 100755
--- a/linden/indra/media_plugins/CMakeLists.txt
+++ b/linden/indra/media_plugins/CMakeLists.txt
@@ -8,8 +8,14 @@ if (LINUX)
     add_subdirectory(gstreamer010)
 endif (LINUX)
 
-if (WINDOWS OR DARWIN)
+# We use gstreamer for audio, quicktime for media on win-- MC
+if (WINDOWS)
+    add_subdirectory(gstreamer010)
+    add_subdirectory(quicktime)
+endif (WINDOWS)
+
+if (DARWIN)
     add_subdirectory(quicktime)
-endif (WINDOWS OR DARWIN)
+endif (DARWIN)
 
 add_subdirectory(example)
diff --git a/linden/indra/media_plugins/gstreamer010/CMakeLists.txt b/linden/indra/media_plugins/gstreamer010/CMakeLists.txt
index 4401e64..e405dc6 100644
--- a/linden/indra/media_plugins/gstreamer010/CMakeLists.txt
+++ b/linden/indra/media_plugins/gstreamer010/CMakeLists.txt
@@ -36,9 +36,15 @@ set(media_plugin_gstreamer010_SOURCE_FILES
     )
 
 set(media_plugin_gstreamer010_HEADER_FILES
+    llmediaimplgstreamer.h
     llmediaimplgstreamervidplug.h
     llmediaimplgstreamertriviallogging.h
     )
+        
+set_source_files_properties(${media_plugin_gstreamer010_HEADER_FILES}
+                                                        PROPERTIES HEADER_FILE_ONLY TRUE)
+
+list(APPEND media_plugin_gstreamer010_SOURCE_FILES ${media_plugin_gstreamer010_HEADER_FILES})
 
 add_library(media_plugin_gstreamer010
     SHARED
diff --git a/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamertriviallogging.h b/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamertriviallogging.h
index bb90aa1..7917232 100755
--- a/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamertriviallogging.h
+++ b/linden/indra/media_plugins/gstreamer010/llmediaimplgstreamertriviallogging.h
@@ -41,7 +41,7 @@
 /////////////////////////////////////////////////////////////////////////
 // Debug/Info/Warning macros.
 #if LL_WINDOWS
-#include <process.h>
+#include <windows.h>
 #define LL_GETPID GetCurrentProcessId
 #else
 #include <sys/types.h>
diff --git a/linden/indra/media_plugins/gstreamer010/media_plugin_gstreamer010.cpp b/linden/indra/media_plugins/gstreamer010/media_plugin_gstreamer010.cpp
index 3637f6b..6a44887 100755
--- a/linden/indra/media_plugins/gstreamer010/media_plugin_gstreamer010.cpp
+++ b/linden/indra/media_plugins/gstreamer010/media_plugin_gstreamer010.cpp
@@ -83,6 +83,9 @@ public:
         gboolean processGSTEvents(GstBus     *bus,
                                   GstMessage *message);
 
+        // basic log file writing
+        static bool writeToLog(char* str, ...);
+
 private:
         std::string getVersion();
         bool navigateTo( const std::string urlIn );
@@ -178,8 +181,7 @@ MediaPluginGStreamer010::MediaPluginGStreamer010(
         mVideoSink ( NULL ),
         mCommand ( COMMAND_NONE )
 {
-        std::ostringstream str;
-        INFOMSG("MediaPluginGStreamer010 constructor - my PID=%u", U32(LL_GETPID()));
+        writeToLog("MediaPluginGStreamer010 PID=%u", U32(LL_GETPID()));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -199,6 +201,29 @@ static char* get_gst_state_name(GstState state)
 }
 #endif // LL_GST_REPORT_STATE_CHANGES
 
+// static
+bool MediaPluginGStreamer010::writeToLog(char* str, ...)
+{
+        LLFILE* fp = LLFile::fopen("media_plugin_gstreamer010.log", "a");
+
+    if (!fp)
+        {
+          return false;
+        }
+
+        time_t timeptr = time(NULL);
+        struct tm* ltime = localtime(&timeptr);
+        fprintf(fp, "[%d:%d:%d] ", ltime->tm_hour, ltime->tm_min, ltime->tm_sec);
+    va_list arglist;
+    va_start(arglist, str);
+    vfprintf(fp, str, arglist);
+    va_end(arglist);
+    fprintf(fp, " \n");
+        fclose(fp);
+
+    return true;
+}
+
 gboolean
 MediaPluginGStreamer010::processGSTEvents(GstBus     *bus,
                                           GstMessage *message)
@@ -206,17 +231,12 @@ MediaPluginGStreamer010::processGSTEvents(GstBus     *bus,
         if (!message) 
                 return TRUE; // shield against GStreamer bug
 
+        // TODO: grok 'duration' message type
         if (GST_MESSAGE_TYPE(message) != GST_MESSAGE_STATE_CHANGED &&
-            GST_MESSAGE_TYPE(message) != GST_MESSAGE_BUFFERING)
+                GST_MESSAGE_TYPE(message) != GST_MESSAGE_BUFFERING &&
+            GST_MESSAGE_TYPE(message) != GST_MESSAGE_TAG)
         {
-                DEBUGMSG("Got GST message type: %s",
-                        GST_MESSAGE_TYPE_NAME (message));
-        }
-        else
-        {
-                // TODO: grok 'duration' message type
-                DEBUGMSG("Got GST message type: %s",
-                         GST_MESSAGE_TYPE_NAME (message));
+                writeToLog("Got GST message type: %s", GST_MESSAGE_TYPE_NAME (message));
         }
 
         switch (GST_MESSAGE_TYPE (message))
@@ -226,7 +246,7 @@ MediaPluginGStreamer010::processGSTEvents(GstBus     *bus,
                         // NEEDS GST 0.10.11+ and America discovered by C.Columbus
                         gint percent = 0;
                         gst_message_parse_buffering(message, &percent);
-                        DEBUGMSG("GST buffering: %d%%", percent);
+                        writeToLog("GST buffering: %d%%", percent);
 
                         break;
                 }
@@ -240,7 +260,7 @@ MediaPluginGStreamer010::processGSTEvents(GstBus     *bus,
                                                         &pending_state);
                         #ifdef LL_GST_REPORT_STATE_CHANGES
                         // not generally very useful, and rather spammy.
-                        DEBUGMSG("state change (old,<new>,pending): %s,<%s>,%s",
+                        writeToLog("state change (old,<new>,pending): %s,<%s>,%s",
                                 get_gst_state_name(old_state),
                                 get_gst_state_name(new_state),
                                 get_gst_state_name(pending_state));
@@ -270,7 +290,7 @@ MediaPluginGStreamer010::processGSTEvents(GstBus     *bus,
                         gchar *debug = NULL;
         
                         gst_message_parse_error (message, &err, &debug);
-                        WARNMSG("GST error: %s", err?err->message:"(unknown)");
+                        writeToLog("GST error: %s", err?err->message:"(unknown)");
                         if (err)
                                 g_error_free (err);
                         g_free (debug);
@@ -287,7 +307,7 @@ MediaPluginGStreamer010::processGSTEvents(GstBus     *bus,
                         gchar *debug = NULL;
                         
                         gst_message_parse_info (message, &err, &debug);
-                        INFOMSG("GST info: %s", err?err->message:"(unknown)");
+                        writeToLog("GST info: %s", err?err->message:"(unknown)");
                         if (err)
                                 g_error_free (err);
                         g_free (debug);
@@ -300,7 +320,7 @@ MediaPluginGStreamer010::processGSTEvents(GstBus     *bus,
                         gchar *debug = NULL;
         
                         gst_message_parse_warning (message, &err, &debug);
-                        WARNMSG("GST warning: %s", err?err->message:"(unknown)");
+                        writeToLog("GST warning: %s", err?err->message:"(unknown)");
                         if (err)
                                 g_error_free (err);
                         g_free (debug);
@@ -317,7 +337,7 @@ MediaPluginGStreamer010::processGSTEvents(GstBus     *bus,
 
                         if ( gst_tag_list_get_string(new_tags, GST_TAG_TITLE, &title) )
                         {
-                                //WARMING("Title: %s", title);
+                                //writeToLog("Title: %s", title);
                                 std::string newtitle(title);
                                 gst_tag_list_free(new_tags);
 
@@ -336,10 +356,10 @@ MediaPluginGStreamer010::processGSTEvents(GstBus     *bus,
                 case GST_MESSAGE_EOS:
                 {
                         /* end-of-stream */
-                        DEBUGMSG("GST end-of-stream.");
+                        writeToLog("GST end-of-stream.");
                         if (mIsLooping)
                         {
-                                DEBUGMSG("looping media...");
+                                //writeToLog("looping media...");
                                 double eos_pos_sec = 0.0F;
                                 bool got_eos_position = getTimePos(eos_pos_sec);
         
@@ -348,7 +368,7 @@ MediaPluginGStreamer010::processGSTEvents(GstBus     *bus,
                                         // if we know that the movie is really short, don't
                                         // loop it else it can easily become a time-hog
                                         // because of GStreamer spin-up overhead
-                                        DEBUGMSG("really short movie (%0.3fsec) - not gonna loop this, pausing instead.", eos_pos_sec);
+                                        writeToLog("really short movie (%0.3fsec) - not gonna loop this, pausing instead.", eos_pos_sec);
                                         // inject a COMMAND_PAUSE
                                         mCommand = COMMAND_PAUSE;
                                 }
@@ -367,7 +387,7 @@ MediaPluginGStreamer010::processGSTEvents(GstBus     *bus,
                                         else
                                         #endif // LLGST_LOOP_BY_SEEKING
                                         {  // use clumsy stop-start to loop
-                                                DEBUGMSG("didn't loop by rewinding - stopping and starting instead...");
+                                                writeToLog("didn't loop by rewinding - stopping and starting instead...");
                                                 stop();
                                                 play(1.0);
                                         }
@@ -413,7 +433,7 @@ MediaPluginGStreamer010::navigateTo ( const std::string urlIn )
 
         setStatus(STATUS_LOADING);
 
-        DEBUGMSG("Setting media URI: %s", urlIn.c_str());
+        writeToLog("Setting media URI: %s", urlIn.c_str());
 
         mSeekWanted = false;
 
@@ -441,13 +461,13 @@ MediaPluginGStreamer010::update(int milliseconds)
         if (!mDoneInit)
                 return false; // error
 
-        DEBUGMSG("updating media...");
+        //writeToLog("updating media...");
         
         // sanity check
         if (NULL == mPump ||
             NULL == mPlaybin)
         {
-                DEBUGMSG("dead media...");
+                writeToLog("dead media...");
                 return false;
         }
 
@@ -477,7 +497,7 @@ MediaPluginGStreamer010::update(int milliseconds)
                 GST_OBJECT_LOCK(mVideoSink);
                 if (mVideoSink->retained_frame_ready)
                 {
-                        DEBUGMSG("NEW FRAME READY");
+                        writeToLog("NEW FRAME READY");
 
                         if (mVideoSink->retained_frame_width != mCurrentWidth ||
                             mVideoSink->retained_frame_height != mCurrentHeight)
@@ -508,7 +528,7 @@ MediaPluginGStreamer010::update(int milliseconds)
                                 GST_OBJECT_UNLOCK(mVideoSink);
 
                                 mCurrentRowbytes = neww * newd;
-                                DEBUGMSG("video container resized to %dx%d",
+                                writeToLog("video container resized to %dx%d",
                                          neww, newh);
 
                                 mDepth = newd;
@@ -536,7 +556,7 @@ MediaPluginGStreamer010::update(int milliseconds)
                                 }
 
                                 GST_OBJECT_UNLOCK(mVideoSink);
-                                DEBUGMSG("NEW FRAME REALLY TRULY CONSUMED, TELLING HOST");
+                                writeToLog("NEW FRAME REALLY TRULY CONSUMED, TELLING HOST");
 
                                 setDirty(0,0,mCurrentWidth,mCurrentHeight);
                         }
@@ -547,7 +567,7 @@ MediaPluginGStreamer010::update(int milliseconds)
 
                                 GST_OBJECT_UNLOCK(mVideoSink);
 
-                                DEBUGMSG("NEW FRAME not consumed, still waiting for a shm segment and/or shm resize");
+                                writeToLog("NEW FRAME not consumed, still waiting for a shm segment and/or shm resize");
                         }
 
                         return true;
@@ -586,7 +606,7 @@ MediaPluginGStreamer010::mouseMove( int x, int y )
 bool
 MediaPluginGStreamer010::pause()
 {
-        DEBUGMSG("pausing media...");
+        writeToLog("pausing media...");
         // todo: error-check this?
         gst_element_set_state(mPlaybin, GST_STATE_PAUSED);
         return true;
@@ -595,7 +615,7 @@ MediaPluginGStreamer010::pause()
 bool
 MediaPluginGStreamer010::stop()
 {
-        DEBUGMSG("stopping media...");
+        writeToLog("stopping media...");
         // todo: error-check this?
         gst_element_set_state(mPlaybin, GST_STATE_READY);
         return true;
@@ -605,8 +625,7 @@ bool
 MediaPluginGStreamer010::play(double rate)
 {
         // NOTE: we don't actually support non-natural rate.
-
-        DEBUGMSG("playing media... rate=%f", rate);
+        writeToLog("playing media... rate=%f", rate);
         // todo: error-check this?
         gst_element_set_state(mPlaybin, GST_STATE_PLAYING);
         return true;
@@ -643,7 +662,7 @@ MediaPluginGStreamer010::seek(double time_sec)
                                 GST_SEEK_TYPE_SET, gint64(time_sec*GST_SECOND),
                                 GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
         }
-        DEBUGMSG("MEDIA SEEK REQUEST to %fsec result was %d",
+        writeToLog("MEDIA SEEK REQUEST to %f sec result was %d",
                  float(time_sec), int(success));
         return success;
 }
@@ -697,7 +716,7 @@ MediaPluginGStreamer010::load()
 
         setStatus(STATUS_LOADING);
 
-        DEBUGMSG("setting up media...");
+        writeToLog("setting up media...");
 
         mIsLooping = false;
         mVolume = (float) 0.1234567; // minor hack to force an initial volume update
@@ -736,7 +755,7 @@ MediaPluginGStreamer010::load()
                         GST_SLVIDEO(gst_element_factory_make ("private-slvideo", "slvideo"));
                 if (!mVideoSink)
                 {
-                        WARNMSG("Could not instantiate private-slvideo element.");
+                        writeToLog("Could not instantiate private-slvideo element.");
                         // todo: cleanup.
                         setStatus(STATUS_ERROR);
                         return false; // error
@@ -755,7 +774,7 @@ MediaPluginGStreamer010::unload ()
         if (!mDoneInit)
                 return false; // error
 
-        DEBUGMSG("unloading media...");
+        writeToLog("unloading media...");
         
         // stop getting callbacks for this bus
         g_source_remove(mBusWatchID);
@@ -813,7 +832,7 @@ MediaPluginGStreamer010::startup()
                                     "libgstvideo-0.10.so.0") )
 #endif
                 {
-                        WARNMSG("Couldn't find suitable GStreamer 0.10 support on this system - video playback disabled.");
+                        writeToLog("Couldn't find suitable GStreamer 0.10 support on this system - video playback disabled.");
                         return false;
                 }
 */
@@ -823,7 +842,7 @@ MediaPluginGStreamer010::startup()
 //              }
 //              else
 //              {
-//                      WARNMSG("gst_segtrap_set_enabled() is not available; plugin crashes won't be caught.");
+//                      writeToLog("gst_segtrap_set_enabled() is not available; plugin crashes won't be caught.");
 //              }
 /*
 #if LL_LINUX
@@ -866,12 +885,12 @@ MediaPluginGStreamer010::startup()
                 {
                         if (err)
                         {
-                                WARNMSG("GST init failed: %s", err->message);
+                                writeToLog("GST init failed: %s", err->message);
                                 g_error_free(err);
                         }
                         else
                         {
-                                WARNMSG("GST init failed for unspecified reason.");
+                                writeToLog("GST init failed for unspecified reason.");
                         }
                         return false;
                 }
@@ -882,22 +901,22 @@ MediaPluginGStreamer010::startup()
 
                 // Init our custom plugins - only really need do this once.
                 gst_slvideo_init_class();
-/*
+
                 // List the plugins GStreamer can find
-                LL_DEBUGS("MediaImpl") << "Found GStreamer plugins:" << LL_ENDL;
+                writeToLog("Found GStreamer plugins:");
                 GList *list;
                 GstRegistry *registry = gst_registry_get_default();
-                std::string loaded = "";
+                std::string loaded = "No";
                 for (list = gst_registry_get_plugin_list(registry);
                      list != NULL;
                      list = g_list_next(list))
                 {        
                         GstPlugin *list_plugin = (GstPlugin *)list->data;
-                        (bool)gst_plugin_is_loaded(list_plugin) ? loaded = "Yes" : loaded = "No";
-                        LL_DEBUGS("MediaImpl") << gst_plugin_get_name(list_plugin) << ", loaded? " << loaded << LL_ENDL;
+                        if (gst_plugin_is_loaded(list_plugin)) loaded = "Yes";
+                        writeToLog("%s, loaded? %s", gst_plugin_get_name(list_plugin), loaded.c_str());
                 }
                 gst_plugin_list_free(list);
-*/
+
                 mDoneInit = true;
         }
 
@@ -941,11 +960,11 @@ void MediaPluginGStreamer010::set_gst_plugin_path()
 
         if( imp_dir == "" )
         {
-                WARNMSG("Could not get application directory, not setting GST_PLUGIN_PATH.");
+                writeToLog("Could not get application directory, not setting GST_PLUGIN_PATH.");
                 return;
         }
 
-        DEBUGMSG("meta-impy is installed at %s", imp_dir);
+        writeToLog("meta-impy is installed at %s", imp_dir.c_str());
 
         // ":" on Mac and 'Nix, ";" on Windows
         std::string separator = G_SEARCHPATH_SEPARATOR_S;
@@ -955,7 +974,7 @@ void MediaPluginGStreamer010::set_gst_plugin_path()
         char *old_path = getenv("GST_PLUGIN_PATH");
         if(old_path == NULL)
         {
-                DEBUGMSG("Did not find user-set GST_PLUGIN_PATH.");
+                writeToLog("Did not find user-set GST_PLUGIN_PATH.");
         }
         else
         {
@@ -986,11 +1005,11 @@ void MediaPluginGStreamer010::set_gst_plugin_path()
 
         if( put_result == -1 )
         {
-                WARNMSG("Setting GST_PLUGIN_PATH failed!");
+                writeToLog("Setting GST_PLUGIN_PATH failed!");
         }
         else
         {
-                DEBUGMSG("GST_PLUGIN_PATH set to %s", getenv("GST_PLUGIN_PATH"));
+                writeToLog("GST_PLUGIN_PATH set to %s", getenv("GST_PLUGIN_PATH"));
         }
                 
         // Don't load system plugins. We only want to use ours, to avoid conflicts.
@@ -1002,7 +1021,7 @@ void MediaPluginGStreamer010::set_gst_plugin_path()
 
         if( put_result == -1 )
         {
-                WARNMSG("Setting GST_PLUGIN_SYSTEM_PATH=\"\" failed!");
+                writeToLog("Setting GST_PLUGIN_SYSTEM_PATH=\"\" failed!");
         }
                 
 #endif // LL_WINDOWS || LL_DARWIN
@@ -1020,7 +1039,7 @@ MediaPluginGStreamer010::sizeChanged()
         {
                 mNaturalWidth = mCurrentWidth;
                 mNaturalHeight = mCurrentHeight;
-                DEBUGMSG("Media NATURAL size better detected as %dx%d",
+                writeToLog("Media NATURAL size better detected as %dx%d",
                          mNaturalWidth, mNaturalHeight);
         }
 
@@ -1035,7 +1054,7 @@ MediaPluginGStreamer010::sizeChanged()
                 message.setValue("name", mTextureSegmentName);
                 message.setValueS32("width", mNaturalWidth);
                 message.setValueS32("height", mNaturalHeight);
-                DEBUGMSG("<--- Sending size change request to application with name: '%s' - natural size is %d x %d", mTextureSegmentName.c_str(), mNaturalWidth, mNaturalHeight);
+                writeToLog("<--- Sending size change request to application with name: '%s' - natural size is %d x %d", mTextureSegmentName.c_str(), mNaturalWidth, mNaturalHeight);
                 sendMessage(message);
         }
 }
@@ -1058,11 +1077,11 @@ MediaPluginGStreamer010::closedown()
 
 MediaPluginGStreamer010::~MediaPluginGStreamer010()
 {
-        DEBUGMSG("MediaPluginGStreamer010 destructor");
+        //writeToLog("MediaPluginGStreamer010 destructor");
 
         closedown();
 
-        DEBUGMSG("GStreamer010 closing down");
+        writeToLog("GStreamer010 closing down");
 }
 
 
@@ -1085,7 +1104,7 @@ MediaPluginGStreamer010::getVersion()
 
 void MediaPluginGStreamer010::receiveMessage(const char *message_string)
 {
-        //std::cerr << "MediaPluginGStreamer010::receiveMessage: received message: \"" << message_string << "\"" << std::endl;
+        //std::cerr << "MediaPluginGStreamer010::receiveMessage: received message: \"" << message_string << "\"";
 
         LLPluginMessage message_in;
 
@@ -1106,11 +1125,11 @@ void MediaPluginGStreamer010::receiveMessage(const char *message_string)
 
                                 if ( load() )
                                 {
-                                        DEBUGMSG("GStreamer010 media instance set up");
+                                        writeToLog("GStreamer010 media instance set up");
                                 }
                                 else
                                 {
-                                        WARNMSG("GStreamer010 media instance failed to set up");
+                                        writeToLog("GStreamer010 media instance failed to set up");
                                 }
 
                                 message.setValue("plugin_version", getVersion());
@@ -1137,7 +1156,7 @@ void MediaPluginGStreamer010::receiveMessage(const char *message_string)
                                 std::string name = message_in.getValue("name");
 
                                 std::ostringstream str;
-                                INFOMSG("MediaPluginGStreamer010::receiveMessage: shared memory added, name: %s, size: %d, address: %p", name.c_str(), int(info.mSize), info.mAddress);
+                                writeToLog("MediaPluginGStreamer010::receiveMessage: shared memory added, name: %s, size: %d, address: %p", name.c_str(), int(info.mSize), info.mAddress);
 
                                 mSharedSegments.insert(SharedSegmentMap::value_type(name, info));
                         }
@@ -1145,7 +1164,7 @@ void MediaPluginGStreamer010::receiveMessage(const char *message_string)
                         {
                                 std::string name = message_in.getValue("name");
 
-                                DEBUGMSG("MediaPluginGStreamer010::receiveMessage: shared memory remove, name = %s", name.c_str());
+                                writeToLog("MediaPluginGStreamer010::receiveMessage: shared memory remove, name = %s", name.c_str());
                                 
                                 SharedSegmentMap::iterator iter = mSharedSegments.find(name);
                                 if(iter != mSharedSegments.end())
@@ -1163,7 +1182,7 @@ void MediaPluginGStreamer010::receiveMessage(const char *message_string)
                                 }
                                 else
                                 {
-                                        WARNMSG("MediaPluginGStreamer010::receiveMessage: unknown shared memory region!");
+                                        writeToLog("MediaPluginGStreamer010::receiveMessage: unknown shared memory region!");
                                 }
 
                                 // Send the response so it can be cleaned up.
@@ -1174,7 +1193,7 @@ void MediaPluginGStreamer010::receiveMessage(const char *message_string)
                         else
                         {
                                 std::ostringstream str;
-                                INFOMSG("MediaPluginGStreamer010::receiveMessage: unknown base message: %s", message_name.c_str());
+                                writeToLog("MediaPluginGStreamer010::receiveMessage: unknown base message: %s", message_name.c_str());
                         }
                 }
                 else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA)
@@ -1217,7 +1236,7 @@ void MediaPluginGStreamer010::receiveMessage(const char *message_string)
                                 S32 texture_height = message_in.getValueS32("texture_height");
 
                                 std::ostringstream str;
-                                INFOMSG("---->Got size change instruction from application with shm name: %s - size is %d x %d", name.c_str(), width, height);
+                                writeToLog("---->Got size change instruction from application with shm name: %s - size is %d x %d", name.c_str(), width, height);
 
                                 LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "size_change_response");
                                 message.setValue("name", name);
@@ -1233,8 +1252,8 @@ void MediaPluginGStreamer010::receiveMessage(const char *message_string)
                                         SharedSegmentMap::iterator iter = mSharedSegments.find(name);
                                         if(iter != mSharedSegments.end())
                                         {
-                                                INFOMSG("*** Got size change with matching shm, new size is %d x %d", width, height);
-                                                INFOMSG("*** Got size change with matching shm, texture size size is %d x %d", texture_width, texture_height);
+                                                writeToLog("*** Got size change with matching shm, new size is %d x %d", width, height);
+                                                writeToLog("*** Got size change with matching shm, texture size size is %d x %d", texture_width, texture_height);
 
                                                 mPixels = (unsigned char*)iter->second.mAddress;
                                                 mTextureSegmentName = name;
@@ -1244,7 +1263,7 @@ void MediaPluginGStreamer010::receiveMessage(const char *message_string)
                                                 if (texture_width > 1 ||
                                                     texture_height > 1) // not a dummy size from the app, a real explicit forced size
                                                 {
-                                                        INFOMSG("**** = REAL RESIZE REQUEST FROM APP");
+                                                        writeToLog("**** = REAL RESIZE REQUEST FROM APP");
                                                         
                                                         GST_OBJECT_LOCK(mVideoSink);
                                                         mVideoSink->resize_forced_always = true;
@@ -1326,13 +1345,23 @@ void MediaPluginGStreamer010::receiveMessage(const char *message_string)
                 }
                 else
                 {
-                        INFOMSG("MediaPluginGStreamer010::receiveMessage: unknown message class: %s", message_class.c_str());
+                        writeToLog("MediaPluginGStreamer010::receiveMessage: unknown message class: %s", message_class.c_str());
                 }
         }
 }
 
 int init_media_plugin(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data, LLPluginInstance::sendMessageFunction *plugin_send_func, void **plugin_user_data)
 {
+        // init log file
+        LLFILE* fp = LLFile::fopen("media_plugin_gstreamer010.log", "w");
+        if (fp)
+        {
+                time_t timeptr = time(NULL);
+                fprintf(fp, "%s", asctime(localtime(&timeptr)));
+                fprintf(fp, "<--- Begin media_plugin_gstreamer010 initialization --->\n");
+                fclose(fp);
+        }
+
         if (MediaPluginGStreamer010::startup())
         {
                 MediaPluginGStreamer010 *self = new MediaPluginGStreamer010(host_send_func, host_user_data);
diff --git a/linden/indra/media_plugins/webkit/linux_volume_catcher.cpp b/linden/indra/media_plugins/webkit/linux_volume_catcher.cpp
index c4c4181..cc3836e 100644
--- a/linden/indra/media_plugins/webkit/linux_volume_catcher.cpp
+++ b/linden/indra/media_plugins/webkit/linux_volume_catcher.cpp
@@ -58,7 +58,7 @@ extern "C" {
 #include <pulse/subscribe.h>
 #include <pulse/glib-mainloop.h> // There's no special reason why we want the *glib* PA mainloop, but the generic polling implementation seems broken.
 
-#include "apr_pools.h"
+#include "aiaprpool.h"
 #include "apr_dso.h"
 }
 
@@ -74,7 +74,7 @@ extern "C" {
 #undef LL_PA_SYM
 
 static bool sSymsGrabbed = false;
-static apr_pool_t *sSymPADSOMemoryPool = NULL;
+static AIAPRPool sSymPADSOMemoryPool;
 static apr_dso_handle_t *sSymPADSOHandleG = NULL;
 
 bool grab_pa_syms(std::string pulse_dso_name)
@@ -93,11 +93,11 @@ bool grab_pa_syms(std::string pulse_dso_name)
 #define LL_PA_SYM(REQUIRED, PASYM, RTN, ...) do{rv = apr_dso_sym((apr_dso_handle_sym_t*)&ll##PASYM, sSymPADSOHandle, #PASYM); if (rv != APR_SUCCESS) {INFOMSG("Failed to grab symbol: %s", #PASYM); if (REQUIRED) sym_error = true;} else DEBUGMSG("grabbed symbol: %s from %p", #PASYM, (void*)ll##PASYM);}while(0)
 
         //attempt to load the shared library
-        apr_pool_create(&sSymPADSOMemoryPool, NULL);
+        sSymPADSOMemoryPool.create();
   
         if ( APR_SUCCESS == (rv = apr_dso_load(&sSymPADSOHandle,
                                                pulse_dso_name.c_str(),
-                                               sSymPADSOMemoryPool) ))
+                                               sSymPADSOMemoryPool()) ))
         {
                 INFOMSG("Found DSO: %s", pulse_dso_name.c_str());
 
@@ -140,11 +140,7 @@ void ungrab_pa_syms()
                 sSymPADSOHandleG = NULL;
         }
         
-        if ( sSymPADSOMemoryPool )
-        {
-                apr_pool_destroy(sSymPADSOMemoryPool);
-                sSymPADSOMemoryPool = NULL;
-        }
+        sSymPADSOMemoryPool.destroy();
         
         // NULL-out all of the symbols we'd grabbed
 #define LL_PA_SYM(REQUIRED, PASYM, RTN, ...) do{ll##PASYM = NULL;}while(0)
diff --git a/linden/indra/media_plugins/webkit/windows_volume_catcher.cpp b/linden/indra/media_plugins/webkit/windows_volume_catcher.cpp
index f1afea7..64f70c4 100644
--- a/linden/indra/media_plugins/webkit/windows_volume_catcher.cpp
+++ b/linden/indra/media_plugins/webkit/windows_volume_catcher.cpp
@@ -34,6 +34,8 @@
  */
 
 #include "volume_catcher.h"
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
 #include <windows.h>
 #include "llmemory.h"
 class VolumeCatcherImpl : public LLSingleton<VolumeCatcherImpl>
diff --git a/linden/indra/newview/CMakeLists.txt b/linden/indra/newview/CMakeLists.txt
index c7d46c2..ff11a7f 100644
--- a/linden/indra/newview/CMakeLists.txt
+++ b/linden/indra/newview/CMakeLists.txt
@@ -87,6 +87,7 @@ set(viewer_SOURCE_FILES
     impprefsfonts.cpp
     jcfloater_animation_list.cpp
     jcfloaterareasearch.cpp
+    kokuastreamingaudio.cpp
     kowopenregionsettings.cpp
     lightshare.cpp
     llagent.cpp
@@ -171,6 +172,7 @@ set(viewer_SOURCE_FILES
     llfloatercustomize.cpp
     llfloaterdaycycle.cpp
     llfloaterdirectory.cpp
+    llfloaterdisplayname.cpp
     llfloatereditui.cpp
     llfloaterenvsettings.cpp
     llfloaterevent.cpp
@@ -408,6 +410,7 @@ set(viewer_SOURCE_FILES
     llviewercamera.cpp
     llviewercontrol.cpp
     llviewerdisplay.cpp
+    llviewerdisplayname.cpp
     llviewergenericmessage.cpp
     llviewergesture.cpp
     llviewerimage.cpp
@@ -540,6 +543,7 @@ set(viewer_HEADER_FILES
     impprefsfonts.h
     jcfloater_animation_list.h
     jcfloaterareasearch.h
+    kokuastreamingaudio.h
     lightshare.h
         lggautocorrectfloater.h
         lggautocorrect.h
@@ -629,6 +633,7 @@ set(viewer_HEADER_FILES
     llfloatercustomize.h
     llfloaterdaycycle.h
     llfloaterdirectory.h
+    llfloaterdisplayname.h
     llfloatereditui.h
     llfloaterenvsettings.h
     llfloaterevent.h
@@ -870,6 +875,7 @@ set(viewer_HEADER_FILES
     llviewercamera.h
     llviewercontrol.h
     llviewerdisplay.h
+    llviewerdisplayname.h
     llviewergenericmessage.h
     llviewergesture.h
     llviewerimage.h
@@ -1366,7 +1372,7 @@ if (WINDOWS)
         DEPENDS ${VIEWER_BINARY_NAME} ${CMAKE_CURRENT_SOURCE_DIR}/viewer_manifest.py
         )
 
-    add_dependencies(${VIEWER_BINARY_NAME} SLPlugin media_plugin_quicktime media_plugin_webkit) # Removed media_plugin_gstreamer010
+    add_dependencies(${VIEWER_BINARY_NAME} SLPlugin media_plugin_quicktime media_plugin_webkit media_plugin_gstreamer010)
 
     if (PACKAGE)
       add_custom_target(package ALL DEPENDS ${CMAKE_CFG_INTDIR}/touched.bat)
@@ -1582,17 +1588,17 @@ if (WINDOWS)
         COMMENT "Copying WebKit Plugin to the runtime folder."
         )
         
-   #get_target_property(BUILT_GSTREAMER_PLUGIN media_plugin_gstreamer010 LOCATION)
-   # add_custom_command(
-   #     TARGET ${VIEWER_BINARY_NAME} POST_BUILD
-   #     COMMAND ${CMAKE_COMMAND}
-   #     ARGS
-   #       -E
-   #       copy_if_different
-   #       ${BUILT_GSTREAMER_PLUGIN}
-   #       ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/llplugin
-   #     COMMENT "Copying Gstreamer Plugin to the runtime folder."
-   #     )
+   get_target_property(BUILT_GSTREAMER_PLUGIN media_plugin_gstreamer010 LOCATION)
+     add_custom_command(
+        TARGET ${VIEWER_BINARY_NAME} POST_BUILD
+        COMMAND ${CMAKE_COMMAND}
+        ARGS
+          -E
+          copy_if_different
+          ${BUILT_GSTREAMER_PLUGIN}
+          ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/llplugin
+        COMMENT "Copying Gstreamer Plugin to the runtime folder."
+        )
         
   get_target_property(BUILT_QUICKTIME_PLUGIN media_plugin_quicktime LOCATION)
     add_custom_command(
diff --git a/linden/indra/newview/app_settings/cloud.xml b/linden/indra/newview/app_settings/cloud.xml
new file mode 100644
index 0000000..ff9492b
--- /dev/null
+++ b/linden/indra/newview/app_settings/cloud.xml
@@ -0,0 +1,88 @@
+<llsd>
+    <map>
+    <key>AngularVelocity</key>
+        <array>
+            <real>0</real>
+            <real>0</real>
+            <real>0</real>
+        </array>
+    <key>BurstPartCount</key>
+        <integer>1</integer>
+    <key>BurstRadius</key>
+        <real>0.3</real>
+    <key>BurstRate</key>
+        <real>0.02</real>
+    <key>BurstSpeedMax</key>
+        <real>1</real>
+    <key>Endcolor</key>
+        <array>
+            <real>0.75</real>
+            <real>0.47</real>
+            <real>0.81</real>
+            <real>0</real>
+        </array>
+    <key>Endscale</key>
+        <array>
+            <real>0.02</real>
+            <real>0.02</real>
+        </array>
+    <key>InnerAngle</key>
+        <real>3.1415927410125732421875</real>
+    <key>LL_PART_BEAM_MASK</key>
+        <integer>0</integer>
+    <key>LL_PART_BOUNCE_MASK</key>
+        <integer>0</integer>
+    <key>LL_PART_EMISSIVE_MASK</key>
+        <integer>1</integer>
+    <key>LL_PART_FOLLOW_SRC_MASK</key>
+        <integer>0</integer>
+    <key>LL_PART_FOLLOW_VELOCITY_MASK</key>
+        <integer>0</integer>
+    <key>LL_PART_INTERP_COLOR_MASK</key>
+        <integer>1</integer>
+    <key>LL_PART_INTERP_SCALE_MASK</key>
+        <integer>1</integer>
+    <key>LL_PART_SRC_PATTERN_ANGLE</key>
+        <integer>0</integer>
+    <key>LL_PART_SRC_PATTERN_ANGLE_CONE</key>
+        <integer>1</integer>
+    <key>LL_PART_SRC_PATTERN_ANGLE_CONE_EMPTY</key>
+        <integer>0</integer>
+    <key>LL_PART_SRC_PATTERN_DROP</key>
+        <integer>0</integer>
+    <key>LL_PART_SRC_PATTERN_EXPLODE</key>
+        <integer>0</integer>
+    <key>LL_PART_TARGET_LINEAR_MASK</key>
+        <integer>0</integer>
+    <key>LL_PART_TARGET_POS_MASK</key>
+        <integer>1</integer>
+    <key>LL_PART_WIND_MASK</key>
+        <integer>0</integer>
+    <key>OuterAngle</key>
+        <real>0</real>
+    <key>PartImageID</key>
+        <string>0000000000000-0000-0000-000000000000</string>
+    <key>ParticleMaxAge</key>
+        <real>0</real>
+    <key>ParticleStartAge</key>
+        <real>0</real>
+    <key>SourceMaxage</key>
+        <real>4</real>
+    <key>Startcolor</key>
+        <array>
+            <real>0.9</real>
+            <real>0.0</real>
+            <real>0.8</real>
+            <real>0.7</real>
+        </array>
+    <key>Startscale</key>
+        <array>
+            <real>0.8</real>
+            <real>0.8</real>
+        </array>
+    <key>TargetId</key>
+        <string>00000000-0000-0000-0000-000000000000</string>
+    <key>BurstSpeedMin</key>
+        <real>0.1</real>
+    </map>
+</llsd>
diff --git a/linden/indra/newview/app_settings/logcontrol.xml b/linden/indra/newview/app_settings/logcontrol.xml
index c94fc51..353ae72 100644
--- a/linden/indra/newview/app_settings/logcontrol.xml
+++ b/linden/indra/newview/app_settings/logcontrol.xml
@@ -1,7 +1,7 @@
 <llsd>
         <map>
                 <!-- default-level can be ALL, DEBUG, INFO, WARN, ERROR, or NONE -->
-                <key>default-level</key>    <string>INFO</string>
+                <key>default-level</key>    <string>WARN</string>
                 <key>print-location</key>   <boolean>false</boolean>
                 <key>settings</key>
                         <array>
@@ -29,7 +29,7 @@
                                                 </array>
                                 </map>
                                 <map>
-                                        <key>level</key><string>DEBUG</string>
+                                        <key>level</key><string>WARN</string>
                                         <key>functions</key>
                                                 <array>
                                                 </array>
@@ -66,7 +66,15 @@
 
                                                         <!--<string>Messaging</string>-->
                                                         <!--<string>Notifications</string>-->
-              <!--<string>Plugin</string>-->
+                <string>Plugin</string>
+                <string>PluginClassMedia</string>
+                <string>PluginInstance</string>
+                <string>PluginPipe</string>
+                <string>PluginChild</string>
+                <!--<string>PluginSpam</string>-->
+                <string>PluginParent</string>
+                <string>PluginViewerMedia</string>
+
               <!--<string>Radar</string>-->
                                                         <!--<string>ShaderLoading</string>-->
 
diff --git a/linden/indra/newview/app_settings/settings.xml b/linden/indra/newview/app_settings/settings.xml
index 24f4d9a..85574e6 100644
--- a/linden/indra/newview/app_settings/settings.xml
+++ b/linden/indra/newview/app_settings/settings.xml
@@ -419,6 +419,42 @@
     <key>Value</key>
     <integer>0</integer>
   </map>
+
+  <!-- Display Names -->
+    <key>DisplayNamesUsage</key>
+    <map>
+      <key>Comment</key>
+      <string>Usage type for display names: 0 = Legacy name only, 1 = display name only (legacy name when absent), 2 = Display name with legacy name</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>U32</string>
+      <key>Value</key>
+      <integer>2</integer>
+    </map>
+    <key>OmitResidentAsLastName</key>
+    <map>
+      <key>Comment</key>
+      <string>Do not display "Resident" as the last name for new residents in their legacy name</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>1</integer>
+    </map>
+    <key>LegacyNamesForFriends</key>
+    <map>
+      <key>Comment</key>
+      <string>When TRUE, forces the use of the legacy names for the friends list and online notifications</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>1</integer>
+    </map>
+
   <key>EmeraldTemporaryUpload</key>
   <map>
     <key>Comment</key>
@@ -1330,6 +1366,17 @@
     <key>Value</key>
     <integer>1</integer>
   </map>
+  <key>WarnFirstPrivacy</key>
+  <map>
+    <key>Comment</key>
+    <string>Enables FirstPrivacy warning on login</string>
+    <key>Persist</key>
+    <integer>1</integer>
+    <key>Type</key>
+    <string>Boolean</string>
+    <key>Value</key>
+    <integer>1</integer>
+  </map>
   <key>WarnFirstVoiceLicense</key>
   <map>
     <key>Comment</key>
diff --git a/linden/indra/newview/chatbar_as_cmdline.cpp b/linden/indra/newview/chatbar_as_cmdline.cpp
index 0593091..b5a7e8c 100644
--- a/linden/indra/newview/chatbar_as_cmdline.cpp
+++ b/linden/indra/newview/chatbar_as_cmdline.cpp
@@ -69,7 +69,7 @@
 #include "llviewerparcelmgr.h"
 #include "llviewerparcelmedia.h"
 #include "llparcel.h"
-#include "llaudioengine.h"
+#include "kokuastreamingaudio.h"
 #include "llviewerparcelmediaautoplay.h"
 #include "lloverlaybar.h"
 #include "lggautocorrectfloater.h"
@@ -367,7 +367,7 @@ bool cmd_line_chat(std::string revised_text, EChatType type)
                                         {
                                                 gOverlayBar->toggleMusicPlay(gOverlayBar);
                                         }
-                                        gAudiop->startInternetStream(status);
+                                        gAudioStream->startInternetStream(status);
                                         return false;
                                 }
                         }
diff --git a/linden/indra/newview/kokuastreamingaudio.cpp b/linden/indra/newview/kokuastreamingaudio.cpp
new file mode 100644
index 0000000..ed606db
--- /dev/null
+++ b/linden/indra/newview/kokuastreamingaudio.cpp
@@ -0,0 +1,129 @@
+ /** 
+ * @file kokuastreamingaudio.cpp
+ * @brief Definition of KOKUAStreamingAudio base class for streaming audio support
+ *
+ * $LicenseInfo:firstyear=2011&license=viewergpl$
+ * Kokua Viewer Source Code
+ * Copyright (C) 2011, Armin.Weatherwax (at) googlemail.com
+ * for the Kokua Viewer Team, in special for our Imprudence Viewer.
+ * 
+ * The source code in this file ("Source Code") is provided by the author
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL").  Terms of the GPL can be found in doc/GPL-license.txt in this
+ * distribution, or online at 
+ * http://secondlifegrid.net/programs/open_source/licensing/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://secondlifegrid.net/programs/open_source/licensing/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.
+ * 
+ * THIS SOURCE CODE IS PROVIDED "AS IS." THE AUTHOR MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ *
+ * $/LicenseInfo$
+ */
+
+#include "kokuastreamingaudio.h"
+#include "llstreamingaudio.h"
+
+
+KOKUAStreamingAudio* gAudioStream = NULL;
+
+KOKUAStreamingAudio::KOKUAStreamingAudio(LLStreamingAudioInterface *impl) :
+mStreamingAudioImpl (impl)
+{
+
+}
+
+KOKUAStreamingAudio::~KOKUAStreamingAudio()
+{
+        if (mStreamingAudioImpl)
+        {
+                delete mStreamingAudioImpl;
+                mStreamingAudioImpl = NULL;
+        }
+}
+
+LLStreamingAudioInterface* KOKUAStreamingAudio::getStreamingAudioImpl()
+{
+        return mStreamingAudioImpl;
+}
+
+// void KOKUAStreamingAudio::setStreamingAudioImpl(LLStreamingAudioInterface *impl)
+// {
+//      mStreamingAudioImpl = impl;
+// }
+
+// virtual
+void KOKUAStreamingAudio::startInternetStream(const std::string& url)
+{
+        if (mStreamingAudioImpl)
+                mStreamingAudioImpl->start(url);
+}
+
+// virtual
+void KOKUAStreamingAudio::stopInternetStream()
+{
+        if (mStreamingAudioImpl)
+                mStreamingAudioImpl->stop();
+}
+
+// virtual
+void KOKUAStreamingAudio::pauseInternetStream(int pause)
+{
+        if (mStreamingAudioImpl)
+                mStreamingAudioImpl->pause(pause);
+}
+
+// virtual
+void KOKUAStreamingAudio::updateInternetStream()
+{
+        if (mStreamingAudioImpl)
+                mStreamingAudioImpl->update();
+}
+
+// virtual
+KOKUAStreamingAudio::KOKUAAudioPlayState KOKUAStreamingAudio::isInternetStreamPlaying()
+{
+        if (mStreamingAudioImpl)
+                return (KOKUAStreamingAudio::KOKUAAudioPlayState) mStreamingAudioImpl->isPlaying();
+
+        return KOKUAStreamingAudio::AUDIO_STOPPED; // Stopped
+}
+
+// virtual
+void KOKUAStreamingAudio::setInternetStreamGain(F32 vol)
+{
+        if (mStreamingAudioImpl)
+                mStreamingAudioImpl->setGain(vol);
+}
+
+F32 KOKUAStreamingAudio::getInternetStreamGain()
+{
+        if (mStreamingAudioImpl)
+                return mStreamingAudioImpl->getGain();
+        else
+                return 1.0f;
+}
+
+// virtual
+std::string KOKUAStreamingAudio::getInternetStreamURL()
+{
+        if (mStreamingAudioImpl)
+                return mStreamingAudioImpl->getURL();
+        else return std::string();
+}
+
+std::string KOKUAStreamingAudio::getVersion()
+{
+        if (mStreamingAudioImpl)
+                return mStreamingAudioImpl->getVersion();
+        else return std::string();
+}
\ No newline at end of file
diff --git a/linden/indra/newview/kokuastreamingaudio.h b/linden/indra/newview/kokuastreamingaudio.h
new file mode 100644
index 0000000..eb49f25
--- /dev/null
+++ b/linden/indra/newview/kokuastreamingaudio.h
@@ -0,0 +1,71 @@
+/** 
+ * @file kokuastreamingaudio.h
+ * @brief Definition of KOKUAStreamingAudio base class for streaming audio support
+ *
+ * $LicenseInfo:firstyear=2011&license=viewergpl$
+ * Kokua Viewer Source Code
+ * Copyright (C) 2011, Armin.Weatherwax (at) googlemail.com
+ * for the Kokua Viewer Team.
+ * 
+ * The source code in this file ("Source Code") is provided by the author
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL").  Terms of the GPL can be found in doc/GPL-license.txt in this
+ * distribution, or online at 
+ * http://secondlifegrid.net/programs/open_source/licensing/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://secondlifegrid.net/programs/open_source/licensing/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.
+ * 
+ * THIS SOURCE CODE IS PROVIDED "AS IS." THE AUTHOR MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ *
+ * $/LicenseInfo$
+ */
+#ifndef KOKUA_STREAMINGAUDIO_H
+#define KOKUA_STREAMINGAUDIO_H
+
+#include "linden_common.h"
+
+class LLStreamingAudioInterface;
+
+class KOKUAStreamingAudio 
+{
+public:
+        enum KOKUAAudioPlayState
+        {
+                // isInternetStreamPlaying() returns an *int*, with
+                // 0 = stopped, 1 = playing, 2 = paused.
+                AUDIO_STOPPED = 0,
+                AUDIO_PLAYING = 1,
+                AUDIO_PAUSED = 2
+        };
+
+        KOKUAStreamingAudio(LLStreamingAudioInterface *impl);
+        virtual ~KOKUAStreamingAudio();
+
+        LLStreamingAudioInterface *getStreamingAudioImpl();
+//      void setStreamingAudioImpl(LLStreamingAudioInterface *impl);
+        void startInternetStream(const std::string& url);
+        void stopInternetStream();
+        void pauseInternetStream(int pause);
+        void updateInternetStream(); 
+        KOKUAAudioPlayState isInternetStreamPlaying();
+        void setInternetStreamGain(F32 vol);
+        F32 getInternetStreamGain();
+        std::string getInternetStreamURL();
+        std::string getVersion();       
+private:
+        LLStreamingAudioInterface *mStreamingAudioImpl;
+};
+
+extern KOKUAStreamingAudio* gAudioStream;
+
+#endif
diff --git a/linden/indra/newview/llagent.cpp b/linden/indra/newview/llagent.cpp
index 5a1700a..515d588 100644
--- a/linden/indra/newview/llagent.cpp
+++ b/linden/indra/newview/llagent.cpp
@@ -7488,7 +7488,7 @@ void LLAgent::sendAgentSetAppearance()
                  param;
                  param = (LLViewerVisualParam*)mAvatarObject->getNextVisualParam())
         {
-                if (param->getGroup() == VISUAL_PARAM_GROUP_TWEAKABLE)
+                if (param->getGroup() == VISUAL_PARAM_GROUP_TWEAKABLE) // do not transmit params of group VISUAL_PARAM_GROUP_TWEAKABLE_NO_TRANSMIT
                 {
                         msg->nextBlockFast(_PREHASH_VisualParam );
                         
diff --git a/linden/indra/newview/llappviewer.cpp b/linden/indra/newview/llappviewer.cpp
index d7b6814..5826041 100644
--- a/linden/indra/newview/llappviewer.cpp
+++ b/linden/indra/newview/llappviewer.cpp
@@ -104,6 +104,7 @@
 #include "llassetstorage.h"
 #include "llpolymesh.h"
 #include "llcachename.h"
+#include "kokuastreamingaudio.h"
 #include "llaudioengine.h"
 #include "llstreamingaudio.h"
 #include "llviewermenu.h"
@@ -920,7 +921,7 @@ bool LLAppViewer::mainLoop()
         //-------------------------------------------
 
         // Create IO Pump to use for HTTP Requests.
-        gServicePump = new LLPumpIO(gAPRPoolp);
+        gServicePump = new LLPumpIO;
         LLHTTPClient::setPump(*gServicePump);
         LLCurl::setCAFile(gDirUtilp->getCAFile());
         
@@ -1258,6 +1259,7 @@ bool LLAppViewer::cleanup()
 
         LLPolyMesh::freeAllMeshes();
 
+        LLAvatarNameCache::cleanupClass();
         delete gCacheName;
         gCacheName = NULL;
 
@@ -1278,14 +1280,16 @@ bool LLAppViewer::cleanup()
         
         llinfos << "Global stuff deleted" << llendflush;
 
-        if (gAudiop)
+        if (gAudioStream)
         {
                 // shut down the streaming audio sub-subsystem first, in case it relies on not outliving the general audio subsystem.
 
-                LLStreamingAudioInterface *sai = gAudiop->getStreamingAudioImpl();
-                delete sai;
-                gAudiop->setStreamingAudioImpl(NULL);
+                delete gAudioStream;
+                gAudioStream = NULL;
+        }
 
+        if (gAudiop)
+        {
                 // shut down the audio subsystem
 
                 bool want_longname = false;
@@ -1642,19 +1646,37 @@ bool LLAppViewer::initLogging()
         LLError::initForApplication(
                                 gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, ""));
         LLError::setFatalFunction(errorCallback);
-        
-        // Remove the last ".old" log file.
-        std::string old_log_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,
-                                                             "meta-impy.old");
-        LLFile::remove(old_log_file);
+        std::string log_name = "meta-impy.log";
 
-        // Rename current log file to ".old"
-        std::string log_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,
-                                                             "meta-impy.log");
-        LLFile::rename(log_file, old_log_file);
+        const int MAX_ROTATION = 5;
+        for(int i = MAX_ROTATION; 0 < i; i--)
+        {
+                std::ostringstream current;
+                current << ".";
+                current << i;
 
-        // Set the log file to Imprudence.log
+                std::ostringstream previous;
+                if( 1 < i )
+                {
+                        previous << ".";
+                        previous << i-1;
+                }
+
+                std::string current_log_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,
+                                                             log_name + current.str());
+                std::string previous_log_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,
+                                                             log_name + previous.str());
+
+                if (MAX_ROTATION == i)
+                {
+                        LLFile::remove(current_log_file);
+                }
+
+                LLFile::rename(previous_log_file, current_log_file);
+        }
 
+        // Set the log file to Imprudence.log
+        std::string log_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, log_name);
         LLError::logToFile(log_file);
 
         // *FIX:Mani no error handling here!
@@ -1861,6 +1883,7 @@ bool LLAppViewer::initConfiguration()
         LLFirstUse::addConfigVariable("FirstVoice");
         LLFirstUse::addConfigVariable("FirstMedia");
         LLFirstUse::addConfigVariable("FirstLoginScreen");
+        LLFirstUse::addConfigVariable("FirstPrivacy");
                 
 // [RLVa:KB] - Checked: RLVa-1.0.3a (2009-09-10) | Added: RLVa-1.0.3a
         //LLFirstUse::addConfigVariable(RLV_SETTING_FIRSTUSE_DETACH);
@@ -3296,6 +3319,14 @@ void LLAppViewer::saveFinalSnapshot()
 
 void LLAppViewer::loadNameCache()
 {
+        // display names cache
+        std::string filename = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "avatar_name_cache.xml");
+        llifstream name_cache_stream(filename);
+        if (name_cache_stream.is_open())
+        {
+                LLAvatarNameCache::importFile(name_cache_stream);
+        }
+
         if (!gCacheName) return;
 
         std::string name_cache;
@@ -3318,6 +3349,14 @@ void LLAppViewer::loadNameCache()
 
 void LLAppViewer::saveNameCache()
 {
+        // display names cache
+        std::string filename = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "avatar_name_cache.xml");
+        llofstream name_cache_stream(filename);
+        if (name_cache_stream.is_open())
+        {
+                LLAvatarNameCache::exportFile(name_cache_stream);
+        }
+
         if (!gCacheName) return;
 
         std::string name_cache;
@@ -3469,18 +3508,22 @@ void LLAppViewer::idle()
                 // Initialize the viewer_stats_timer with an already elapsed time
                 // of SEND_STATS_PERIOD so that the initial stats report will
                 // be sent immediately.
-                static LLFrameStatsTimer viewer_stats_timer(SEND_STATS_PERIOD);
-                reset_statistics();
-
-                // Update session stats every large chunk of time
-                // *FIX: (???) SAMANTHA
-                /* or don't! part of a larger effort to waste less CPU cycles. -Patrick Sapinski (Sunday, November 29, 2009)
-                if (viewer_stats_timer.getElapsedTimeF32() >= SEND_STATS_PERIOD && !gDisconnected)
+                if(!gDisconnected && gHippoGridManager->getConnectedGrid()->isSecondLife())
                 {
-                        llinfos << "Transmitting sessions stats" << llendl;
-                        send_stats();
-                        viewer_stats_timer.reset();
-                } */
+                        static LLFrameStatsTimer viewer_stats_timer(SEND_STATS_PERIOD);
+                        reset_statistics();
+
+                        // Update session stats every large chunk of time
+                        // *FIX: (???) SAMANTHA
+
+                        /* or don't! part of a larger effort to waste less CPU cycles. -Patrick Sapinski (Sunday, November 29, 2009)*/
+                        if (viewer_stats_timer.getElapsedTimeF32() >= SEND_STATS_PERIOD )
+                        {
+                                llinfos << "Transmitting sessions stats" << llendl;
+                                send_stats();
+                                viewer_stats_timer.reset();
+                        } 
+                }
 
                 // Print the object debugging stats
                 static LLFrameTimer object_debug_timer;
@@ -3518,6 +3561,8 @@ void LLAppViewer::idle()
             // floating throughout the various object lists.
             //
     
+                idleNameCache();
+
             gFrameStats.start(LLFrameStats::IDLE_NETWORK);
                 stop_glerror();
                 idleNetwork();
@@ -3732,6 +3777,10 @@ void LLAppViewer::idle()
                         const F32 max_audio_decode_time = 0.002f; // 2 ms decode time
                         gAudiop->idle(max_audio_decode_time);
                 }
+
+                // update streaming audio
+                if (gAudioStream)
+                        gAudioStream->updateInternetStream();
         }
         
 
@@ -3895,6 +3944,60 @@ void LLAppViewer::sendLogoutRequest()
         }
 }
 
+void LLAppViewer::idleNameCache()
+{
+        // Neither old nor new name cache can function before agent has a region
+        LLViewerRegion* region = gAgent.getRegion();
+        if (!region) return;
+
+        // deal with any queued name requests and replies.
+        gCacheName->processPending();
+
+        // Can't run the new cache until we have the list of capabilities
+        // for the agent region, and can therefore decide whether to use
+        // display names or fall back to the old name system.
+        if (!region->capabilitiesReceived()) return;
+
+        // Agent may have moved to a different region, so need to update cap URL
+        // for name lookups.  Can't do this in the cap grant code, as caps are
+        // granted to neighbor regions before the main agent gets there.  Can't
+        // do it in the move-into-region code because cap not guaranteed to be
+        // granted yet, for example on teleport.
+        bool had_capability = LLAvatarNameCache::hasNameLookupURL();
+        std::string name_lookup_url;
+        name_lookup_url.reserve(128); // avoid a memory allocation below
+        name_lookup_url = region->getCapability("GetDisplayNames");
+        bool have_capability = !name_lookup_url.empty();
+        if (have_capability)
+        {
+                // we have support for display names, use it
+            U32 url_size = name_lookup_url.size();
+            // capabilities require URLs with slashes before query params:
+            // https://<host>:<port>/cap/<uuid>/?ids=<blah>
+            // but the caps are granted like:
+            // https://<host>:<port>/cap/<uuid>
+            if (url_size > 0 && name_lookup_url[url_size-1] != '/')
+            {
+                    name_lookup_url += '/';
+            }
+                LLAvatarNameCache::setNameLookupURL(name_lookup_url);
+        }
+        else
+        {
+                // Display names not available on this region
+                LLAvatarNameCache::setNameLookupURL( std::string() );
+        }
+
+        // Error recovery - did we change state?
+        if (had_capability != have_capability)
+        {
+                // name tags are persistant on screen, so make sure they refresh
+                LLVOAvatar::invalidateNameTags();
+        }
+
+        LLAvatarNameCache::idle();
+}
+
 //
 // Handle messages, and all message related stuff
 //
diff --git a/linden/indra/newview/llappviewer.h b/linden/indra/newview/llappviewer.h
index 7c9fe89..522050a 100644
--- a/linden/indra/newview/llappviewer.h
+++ b/linden/indra/newview/llappviewer.h
@@ -192,6 +192,7 @@ private:
     
     void idle(); 
     void idleShutdown();
+    void idleNameCache();
     void idleNetwork();
 
     void sendLogoutRequest();
diff --git a/linden/indra/newview/llappviewerlinux.cpp b/linden/indra/newview/llappviewerlinux.cpp
index 307f925..88ddf7e 100644
--- a/linden/indra/newview/llappviewerlinux.cpp
+++ b/linden/indra/newview/llappviewerlinux.cpp
@@ -129,6 +129,7 @@ int main( int argc, char **argv )
         }
         delete viewer_app_ptr;
         viewer_app_ptr = NULL;
+
         return 0;
 }
 
diff --git a/linden/indra/newview/llappviewermacosx.cpp b/linden/indra/newview/llappviewermacosx.cpp
index 91de066..d81b6e3 100644
--- a/linden/indra/newview/llappviewermacosx.cpp
+++ b/linden/indra/newview/llappviewermacosx.cpp
@@ -119,6 +119,7 @@ int main( int argc, char **argv )
         }
         delete viewer_app_ptr;
         viewer_app_ptr = NULL;
+
         return 0;
 }
 
diff --git a/linden/indra/newview/llappviewerwin32.cpp b/linden/indra/newview/llappviewerwin32.cpp
index 0fc273e..6f67c3f 100644
--- a/linden/indra/newview/llappviewerwin32.cpp
+++ b/linden/indra/newview/llappviewerwin32.cpp
@@ -78,31 +78,6 @@ extern "C" {
 #endif
 #endif
 
-// Force Imprudence to link against the correct boost libraries -- McCabe
-#if defined(_MSC_VER)
-#if _MSC_VER >= 1500
-#ifdef LL_DEBUG
-#pragma comment( lib, "libboost_signals-vc90-mt-gd-1_36.lib" )
-#pragma comment( lib, "libboost_regex-vc90-mt-gd-1_36.lib" )
-#pragma comment( lib, "libboost_program_options-vc90-mt-gd-1_36.lib" )
-#else
-#pragma comment( lib, "libboost_signals-vc90-mt-1_36.lib" )
-#pragma comment( lib, "libboost_regex-vc90-mt-1_36.lib" )
-#pragma comment( lib, "libboost_program_options-vc90-mt-1_36.lib" )
-#endif
-#elif _MSC_VER >= 1400
-#ifdef LL_DEBUG
-#pragma comment( lib, "libboost_signals-vc80-mt-gd-1_36.lib" )
-#pragma comment( lib, "libboost_regex-vc80-mt-gd-1_36.lib" )
-#pragma comment( lib, "libboost_program_options-vc80-mt-gd-1_36.lib" )
-#else
-#pragma comment( lib, "libboost_signals-vc80-mt-1_36.lib" )
-#pragma comment( lib, "libboost_regex-vc80-mt-1_36.lib" )
-#pragma comment( lib, "libboost_program_options-vc80-mt-1_36.lib" )
-#endif
-#endif
-#endif
-
 const std::string LLAppViewerWin32::sWindowClass = "meta-impy";
 
 LONG WINAPI viewer_windows_exception_handler(struct _EXCEPTION_POINTERS *exception_infop)
diff --git a/linden/indra/newview/llcallingcard.cpp b/linden/indra/newview/llcallingcard.cpp
index 15be0eb..f1328be 100644
--- a/linden/indra/newview/llcallingcard.cpp
+++ b/linden/indra/newview/llcallingcard.cpp
@@ -613,6 +613,25 @@ void LLAvatarTracker::processChange(LLMessageSystem* msg)
                                         LLSD args;
                                         if(gCacheName->getName(agent_id, first, last))
                                         {
+                                                if (LLAvatarNameCache::useDisplayNames() && !gSavedSettings.getBOOL("LegacyNamesForFriends"))
+                                                {
+                                                        LLAvatarName avatar_name;
+                                                        if (LLAvatarNameCache::get(agent_id, &avatar_name))
+                                                        {
+                                                                // Always show "Display Name [Legacy Name]" for security reasons
+                                                                first = avatar_name.getNames();
+                                                                size_t i = first.find(" ");
+                                                                if (i != std::string::npos)
+                                                                {
+                                                                        last = first.substr(i + 1);
+                                                                        first = first.substr(0, i);
+                                                                }
+                                                                else
+                                                                {
+                                                                        last = "";
+                                                                }
+                                                        }
+                                                }
                                                 args["FIRST_NAME"] = first;
                                                 args["LAST_NAME"] = last;       
                                         }
@@ -669,6 +688,31 @@ void LLAvatarTracker::processNotify(LLMessageSystem* msg, bool online)
                                         std::string first, last;
                                         if(gCacheName->getName(agent_id, first, last))
                                         {
+                                                if (LLAvatarNameCache::useDisplayNames() && !gSavedSettings.getBOOL("LegacyNamesForFriends"))
+                                                {
+                                                        LLAvatarName avatar_name;
+                                                        if (LLAvatarNameCache::get(agent_id, &avatar_name))
+                                                        {
+                                                                if (LLAvatarNameCache::useDisplayNames() == 1)
+                                                                {
+                                                                        first = avatar_name.mDisplayName;
+                                                                }
+                                                                else
+                                                                {
+                                                                        first = avatar_name.getNames();
+                                                                }
+                                                                size_t i = first.find(" ");
+                                                                if (i != std::string::npos)
+                                                                {
+                                                                        last = first.substr(i + 1);
+                                                                        first = first.substr(0, i);
+                                                                }
+                                                                else
+                                                                {
+                                                                        last = "";
+                                                                }
+                                                        }
+                                                }
                                                 notify = TRUE;
                                                 args["FIRST"] = first;
                                                 args["LAST"] = last;
@@ -745,6 +789,12 @@ void LLAvatarTracker::processTerminateFriendship(LLMessageSystem* msg, void**)
         }
 }
 
+void LLAvatarTracker::dirtyBuddies()
+{
+        mModifyMask |=  LLFriendObserver::REMOVE | LLFriendObserver::ADD;
+        notifyObservers();
+}
+
 ///----------------------------------------------------------------------------
 /// Tracking Data
 ///----------------------------------------------------------------------------
diff --git a/linden/indra/newview/llcallingcard.h b/linden/indra/newview/llcallingcard.h
index d3f53c6..d5496ae 100644
--- a/linden/indra/newview/llcallingcard.h
+++ b/linden/indra/newview/llcallingcard.h
@@ -122,6 +122,9 @@ public:
         // deal with termination of friendhsip
         void terminateBuddy(const LLUUID& id);
 
+        // flag the buddy list dirty to force an update
+        void dirtyBuddies();
+
         // get full info
         const LLRelationship* getBuddyInfo(const LLUUID& id) const;
 
diff --git a/linden/indra/newview/llfilepicker.cpp b/linden/indra/newview/llfilepicker.cpp
index a59fa06..ec4e294 100644
--- a/linden/indra/newview/llfilepicker.cpp
+++ b/linden/indra/newview/llfilepicker.cpp
@@ -1181,7 +1181,7 @@ BOOL LLFilePicker::getSaveFile( ESaveFilter filter, const std::string& filename
                         break;
                 case FFSAVE_RAW:
                         caption += add_simple_pattern_filter_to_gtkchooser
-                                (picker, "*.raw", LLTrans::getString("dot_raw_file") + " (*.raw)");
+                                (picker, "*.raw", LLTrans::getString("raw_file") + " (*.raw)");
                         suggest_ext = ".raw";
                         break;
                 case FFSAVE_J2C:
diff --git a/linden/indra/newview/llfirstuse.cpp b/linden/indra/newview/llfirstuse.cpp
index 18efa9e..f482d1c 100644
--- a/linden/indra/newview/llfirstuse.cpp
+++ b/linden/indra/newview/llfirstuse.cpp
@@ -390,3 +390,31 @@ void LLFirstUse::voiceLicenseAgreement()
                 LLStartUp::setStartupState(STATE_LOGIN_AUTH_INIT);
         }
 }
+
+void LLFirstUse::callbackPrivacy(const LLSD& notification, const LLSD& response)
+{
+
+        S32 option = LLNotification::getSelectedOption(notification, response);
+        if ( 0 == option )
+        {
+                gSavedSettings.setWarning("FirstPrivacy", FALSE);
+                LLStartUp::setStartupState(STATE_PRIVACY_LECTURED);
+        }
+        if ( 1 == option )
+        {
+                LLStartUp::resetLogin();
+        }
+}
+
+// static
+void LLFirstUse::Privacy()
+{
+        if (gSavedSettings.getWarning("FirstPrivacy"))
+        {
+                LLNotifications::instance().add("FirstPrivacy", LLSD(), LLSD(), callbackPrivacy);
+        }
+        else
+        {
+                LLStartUp::setStartupState(STATE_PRIVACY_LECTURED);
+        }
+}
\ No newline at end of file
diff --git a/linden/indra/newview/llfirstuse.h b/linden/indra/newview/llfirstuse.h
index 42443ff..8c2ca35 100644
--- a/linden/indra/newview/llfirstuse.h
+++ b/linden/indra/newview/llfirstuse.h
@@ -116,7 +116,8 @@ public:
         static void callbackClientTags(const LLSD& notification, const LLSD& response);
         static void ClientTags();
         static void voiceLicenseAgreement();
-        
+        static void callbackPrivacy(const LLSD& notification, const LLSD& response);
+        static void Privacy();
 protected:
         static std::set<std::string> sConfigVariables;
 
diff --git a/linden/indra/newview/llfloateractivespeakers.cpp b/linden/indra/newview/llfloateractivespeakers.cpp
index 59de717..75cf176 100644
--- a/linden/indra/newview/llfloateractivespeakers.cpp
+++ b/linden/indra/newview/llfloateractivespeakers.cpp
@@ -92,18 +92,19 @@ LLSpeaker::LLSpeaker(const LLUUID& id, const std::string& name, const ESpeakerTy
 
 void LLSpeaker::lookupName()
 {
-        gCacheName->getName(mID, onAvatarNameLookup, new LLHandle<LLSpeaker>(getHandle()));
+        LLAvatarNameCache::get(mID, boost::bind(&LLSpeaker::onAvatarNameLookup, _1, _2, new LLHandle<LLSpeaker>(getHandle())));
 }
 
 //static 
-void LLSpeaker::onAvatarNameLookup(const LLUUID& id, const std::string& first, const std::string& last, BOOL is_group, void* user_data)
+void LLSpeaker::onAvatarNameLookup(const LLUUID& id, const LLAvatarName& avatar_name, void* user_data)
 {
         LLSpeaker* speaker_ptr = ((LLHandle<LLSpeaker>*)user_data)->get();
         delete (LLHandle<LLSpeaker>*)user_data;
 
         if (speaker_ptr)
         {
-                speaker_ptr->mDisplayName = first + " " + last;
+                // Always show "Display Name [Legacy Name]" for security reasons
+                speaker_ptr->mDisplayName = avatar_name.getNames();
 // [RLVa:KB] - Checked: 2009-07-10 (RLVa-1.0.0g) | Added: RLVa-1.0.0g
                 // TODO-RLVa: this seems to get called per frame which is very likely an LL bug that will eventuall get fixed
                 if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES))
diff --git a/linden/indra/newview/llfloateractivespeakers.h b/linden/indra/newview/llfloateractivespeakers.h
index b2c44e2..dc3dd73 100644
--- a/linden/indra/newview/llfloateractivespeakers.h
+++ b/linden/indra/newview/llfloateractivespeakers.h
@@ -33,6 +33,7 @@
 #ifndef LL_LLFLOATERACTIVESPEAKERS_H
 #define LL_LLFLOATERACTIVESPEAKERS_H
 
+#include "llavatarnamecache.h"
 #include "llfloater.h"
 #include "llmemory.h"
 #include "llvoiceclient.h"
@@ -73,7 +74,7 @@ public:
         ~LLSpeaker() {};
         void lookupName();
 
-        static void onAvatarNameLookup(const LLUUID& id, const std::string& first, const std::string& last, BOOL is_group, void* user_data);
+        static void onAvatarNameLookup(const LLUUID& id, const LLAvatarName& avatar_name, void* user_data);
 
         ESpeakerStatus  mStatus;                        // current activity status in speech group
         F32                             mLastSpokeTime;         // timestamp when this speaker last spoke
diff --git a/linden/indra/newview/llfloateravatarinfo.cpp b/linden/indra/newview/llfloateravatarinfo.cpp
index 0618875..13805fb 100644
--- a/linden/indra/newview/llfloateravatarinfo.cpp
+++ b/linden/indra/newview/llfloateravatarinfo.cpp
@@ -122,7 +122,7 @@ LLFloaterAvatarInfo::LLFloaterAvatarInfo(const std::string& name, const LLRect &
         }
 
         gAvatarInfoInstances.addData(avatar_id, this); // must be done before callback below is called.
-        gCacheName->get(avatar_id, FALSE, callbackLoadAvatarName);
+        LLAvatarNameCache::get(avatar_id, boost::bind(&LLFloaterAvatarInfo::callbackLoadAvatarName, _1, _2));
 }
 
 // virtual
@@ -242,18 +242,16 @@ void LLFloaterAvatarInfo::showProfileCallback(S32 option, void *userdata)
 
 // static
 void LLFloaterAvatarInfo::callbackLoadAvatarName(const LLUUID& id,
-                                                                                                 const std::string& first,
-                                                                                                 const std::string& last,
-                                                                                                 BOOL is_group,
-                                                                                                 void* data)
+                                                                                                 const LLAvatarName& avatar_name)
 {
         LLFloaterAvatarInfo *floater = gAvatarInfoInstances.getIfThere(id);
 
         if (floater)
         {
                 // Build a new title including the avatar name.
+                // Always show "Display Name [Legacy Name]" for security reasons
                 std::ostringstream title;
-                title << first << " " << last << " - " << floater->getTitle();
+                title << avatar_name.getNames() << " - " << floater->getTitle();
                 floater->setTitle(title.str());
         }
 }
diff --git a/linden/indra/newview/llfloateravatarinfo.h b/linden/indra/newview/llfloateravatarinfo.h
index 1cc17d1..f65e1f4 100644
--- a/linden/indra/newview/llfloateravatarinfo.h
+++ b/linden/indra/newview/llfloateravatarinfo.h
@@ -39,6 +39,7 @@
 #ifndef LL_LLFLOATERAVATARINFO_H
 #define LL_LLFLOATERAVATARINFO_H
 
+#include "llavatarnamecache.h"
 #include "llfloater.h"
 #include "llpreview.h"
 #include "lluuid.h"
@@ -91,8 +92,7 @@ public:
 
         static LLFloaterAvatarInfo* getInstance(const LLUUID &id);
         static void showProfileCallback(S32 option, void *userdata);
-        static void callbackLoadAvatarName(const LLUUID& id,
-                const std::string& first, const std::string& last, BOOL is_group, void* data);
+        static void callbackLoadAvatarName(const LLUUID& agent_id, const LLAvatarName& avatar_name);
         void resetGroupList();
 
 private:
diff --git a/linden/indra/newview/llfloaterchatterbox.cpp b/linden/indra/newview/llfloaterchatterbox.cpp
index 1ef75d1..ba1c83c 100644
--- a/linden/indra/newview/llfloaterchatterbox.cpp
+++ b/linden/indra/newview/llfloaterchatterbox.cpp
@@ -43,6 +43,7 @@
 #include "llviewercontrol.h"
 #include "llimview.h"
 #include "llimpanel.h"
+#include "llcallingcard.h"
 
 //
 // LLFloaterMyFriends
@@ -218,6 +219,8 @@ void LLFloaterChatterBox::draw()
 void LLFloaterChatterBox::onOpen()
 {
         gSavedSettings.setBOOL("ShowCommunicate", TRUE);
+        // Force a refresh to get latest display names in the new IM panel.
+        LLAvatarTracker::instance().dirtyBuddies();
 }
 
 void LLFloaterChatterBox::onClose(bool app_quitting)
diff --git a/linden/indra/newview/llfloatercustomize.cpp b/linden/indra/newview/llfloatercustomize.cpp
index db51556..21dfc36 100644
--- a/linden/indra/newview/llfloatercustomize.cpp
+++ b/linden/indra/newview/llfloatercustomize.cpp
@@ -448,9 +448,7 @@ LLPanelEditWearable::LLPanelEditWearable( EWearableType type )
 BOOL LLPanelEditWearable::postBuild()
 {
         LLAssetType::EType asset_type = LLWearable::typeToAssetType( mType );
-        std::string icon_name = (asset_type == LLAssetType::AT_CLOTHING ?
-                                                                                 "inv_item_clothing.tga" :
-                                                                                 "inv_item_skin.tga" );
+        std::string icon_name = get_item_icon_name(asset_type, LLInventoryType::IT_WEARABLE, mType, FALSE);
         childSetValue("icon", icon_name);
 
         childSetAction("Create New", LLPanelEditWearable::onBtnCreateNew, this );
@@ -553,7 +551,7 @@ void LLPanelEditWearable::setSubpart( ESubpart subpart )
                         param = (LLViewerVisualParam *)avatar->getNextVisualParam())
                 {
                         if (param->getID() == -1
-                                || param->getGroup() != VISUAL_PARAM_GROUP_TWEAKABLE 
+                                || !param->isTweakable()
                                 || param->getEditGroup() != part->mEditGroup 
                                 || !(param->getSex() & avatar_sex))
                         {
@@ -763,7 +761,6 @@ void LLPanelEditWearable::onColorCommit( LLUICtrl* ctrl, void* userdata )
         }
 }
 
-
 void LLPanelEditWearable::initPreviousTextureList()
 {
         initPreviousTextureListEntry(TEX_LOWER_ALPHA);
@@ -2338,6 +2335,7 @@ void LLFloaterCustomize::initWearablePanels()
                 panel->addTextureDropTarget(TEX_HEAD_TATTOO, "Head Tattoo",
                                                                         LLUUID::null,
                                                                         TRUE);
+                panel->addColorSwatch(TEX_LOWER_TATTOO, "Color/Tint");
         }
 }
 
diff --git a/linden/indra/newview/llfloaterdirectory.cpp b/linden/indra/newview/llfloaterdirectory.cpp
index 8018c31..7c8ddf1 100644
--- a/linden/indra/newview/llfloaterdirectory.cpp
+++ b/linden/indra/newview/llfloaterdirectory.cpp
@@ -466,7 +466,9 @@ void LLFloaterDirectory::setVisible(BOOL visible)
 
 void LLFloaterDirectory::onClose(bool app_quitting)
 {
-        setVisible(FALSE);
+        LLFloater::onClose(app_quitting);
+
+        //setVisible(FALSE); //meaning you hide 3 web browsers - one SLPlugin each
 }
 
 // static
diff --git a/linden/indra/newview/llfloaterdisplayname.cpp b/linden/indra/newview/llfloaterdisplayname.cpp
new file mode 100644
index 0000000..31ceda9
--- /dev/null
+++ b/linden/indra/newview/llfloaterdisplayname.cpp
@@ -0,0 +1,224 @@
+/** 
+ * @file llfloaterdisplayname.cpp
+ * @author Leyla Farazha
+ * @brief Implementation of the LLFloaterDisplayName class.
+ *
+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+
+#include "llviewerprecompiledheaders.h"
+#include "llfloater.h"
+
+#include "llnotifications.h"
+#include "llviewerdisplayname.h"
+
+#include "llnotify.h"
+#include "llfloaterdisplayname.h"
+#include "llavatarnamecache.h"
+#include "lluictrlfactory.h"
+#include "llviewercontrol.h"
+
+#include "llagent.h"
+
+
+LLFloaterDisplayName* LLFloaterDisplayName::sInstance = NULL;
+
+LLFloaterDisplayName::LLFloaterDisplayName() : LLFloater(std::string("Display Name"))
+{
+        LLUICtrlFactory::getInstance()->buildFloater(this, "floater_display_name.xml");
+        LLFloaterDisplayName::sInstance = this;
+}
+
+LLFloaterDisplayName::~LLFloaterDisplayName()
+{
+        LLFloaterDisplayName::sInstance = NULL;
+}
+
+void LLFloaterDisplayName::show()
+{
+        if (!LLFloaterDisplayName::sInstance)
+        {
+                LLFloaterDisplayName::sInstance = new LLFloaterDisplayName();
+        }
+        LLFloaterDisplayName::sInstance->open();
+}
+
+void LLFloaterDisplayName::onOpen()
+{
+        getChild<LLUICtrl>("display_name_editor")->clear();
+        getChild<LLUICtrl>("display_name_confirm")->clear();
+
+        LLAvatarName av_name;
+        LLAvatarNameCache::get(gAgent.getID(), &av_name);
+
+        F64 now_secs = LLDate::now().secondsSinceEpoch();
+
+        if (now_secs < av_name.mNextUpdate)
+        {
+                // ...can't update until some time in the future
+                F64 next_update_local_secs = av_name.mNextUpdate;
+                std::string next_update_string;
+#ifdef LOCALIZED_TIME
+                timeToFormattedString((time_t)next_update_local_secs,
+                                                          gSavedSettings.getString("LongDateFormat"),
+                                                          next_update_string);
+#else
+                LLDate next_update_local(next_update_local_secs);
+                next_update_string = next_update_local.asString();
+#endif
+                getChild<LLUICtrl>("lockout_text")->setTextArg("[TIME]", next_update_string);
+                getChild<LLUICtrl>("lockout_text")->setVisible(true);
+                getChild<LLUICtrl>("now_ok_text")->setVisible(false);
+                getChild<LLUICtrl>("save_btn")->setEnabled(false);
+                getChild<LLUICtrl>("display_name_editor")->setEnabled(false);
+                getChild<LLUICtrl>("display_name_confirm")->setEnabled(false);
+                getChild<LLUICtrl>("cancel_btn")->setFocus(TRUE);
+                
+        }
+        else
+        {
+                getChild<LLUICtrl>("lockout_text")->setVisible(false);
+                getChild<LLUICtrl>("now_ok_text")->setVisible(true);
+                getChild<LLUICtrl>("save_btn")->setEnabled(true);
+                getChild<LLUICtrl>("display_name_editor")->setEnabled(true);
+                getChild<LLUICtrl>("display_name_confirm")->setEnabled(true);
+
+        }
+}
+
+BOOL LLFloaterDisplayName::postBuild()
+{
+        childSetAction("reset_btn", onReset, this);
+        childSetAction("cancel_btn", onCancel, this);
+        childSetAction("save_btn", onSave, this);
+
+        center();
+
+        return TRUE;
+}
+
+void LLFloaterDisplayName::onCacheSetName(bool success,
+                                                                                  const std::string& reason,
+                                                                                  const LLSD& content)
+{
+        if (success)
+        {
+                // Inform the user that the change took place, but will take a while
+                // to percolate.
+                LLSD args;
+                args["DISPLAY_NAME"] = content["display_name"];
+                LLNotifications::instance().add("SetDisplayNameSuccess", args);
+
+                // Re-fetch my name, as it may have been sanitized by the service
+                //LLAvatarNameCache::get(getAvatarId(),
+                //      boost::bind(&LLPanelMyProfileEdit::onNameCache, this, _1, _2));
+                return;
+        }
+
+        // Request failed, notify the user
+        std::string error_tag = content["error_tag"].asString();
+        llinfos << "set name failure error_tag " << error_tag << llendl;
+
+        // We might have a localized string for this message
+        // error_args will usually be empty from the server.
+        if (!error_tag.empty()
+                && LLNotifications::getInstance()->templateExists(error_tag))
+        {
+                LLNotifications::instance().add(error_tag);
+                return;
+        }
+
+        // The server error might have a localized message for us
+        std::string lang_code = LLUI::getLanguage();
+        LLSD error_desc = content["error_description"];
+        if (error_desc.has( lang_code ))
+        {
+                LLSD args;
+                args["MESSAGE"] = error_desc[lang_code].asString();
+                LLNotifications::instance().add("GenericAlert", args);
+                return;
+        }
+
+        // No specific error, throw a generic one
+        LLNotifications::instance().add("SetDisplayNameFailedGeneric");
+}
+
+void LLFloaterDisplayName::onCancel(void* data)
+{
+        LLFloaterDisplayName* self = (LLFloaterDisplayName*)data;
+        self->setVisible(false);
+}
+
+void LLFloaterDisplayName::onReset(void* data)
+{
+        LLFloaterDisplayName* self = (LLFloaterDisplayName*)data;
+
+        if (LLAvatarNameCache::useDisplayNames())
+        {
+                LLViewerDisplayName::set("",
+                        boost::bind(&LLFloaterDisplayName::onCacheSetName, self, _1, _2, _3));
+        }       
+        else
+        {
+                LLNotifications::instance().add("SetDisplayNameFailedGeneric");
+        }
+
+        self->setVisible(false);
+}
+
+
+void LLFloaterDisplayName::onSave(void* data)
+{
+        LLFloaterDisplayName* self = (LLFloaterDisplayName*)data;
+
+        std::string display_name_utf8 = self->getChild<LLUICtrl>("display_name_editor")->getValue().asString();
+        std::string display_name_confirm = self->getChild<LLUICtrl>("display_name_confirm")->getValue().asString();
+
+        if (display_name_utf8.compare(display_name_confirm))
+        {
+                LLNotifications::instance().add("SetDisplayNameMismatch");
+                return;
+        }
+
+        const U32 DISPLAY_NAME_MAX_LENGTH = 31; // characters, not bytes
+        LLWString display_name_wstr = utf8string_to_wstring(display_name_utf8);
+        if (display_name_wstr.size() > DISPLAY_NAME_MAX_LENGTH)
+        {
+                LLSD args;
+                args["LENGTH"] = llformat("%d", DISPLAY_NAME_MAX_LENGTH);
+                LLNotifications::instance().add("SetDisplayNameFailedLength", args);
+                return;
+        }
+
+        if (LLAvatarNameCache::useDisplayNames())
+        {
+                LLViewerDisplayName::set(display_name_utf8,
+                        boost::bind(&LLFloaterDisplayName::onCacheSetName, self, _1, _2, _3));  
+        }
+        else
+        {
+                LLNotifications::instance().add("SetDisplayNameFailedGeneric");
+        }
+
+        self->setVisible(false);
+}
diff --git a/linden/indra/newview/llfloaterdisplayname.h b/linden/indra/newview/llfloaterdisplayname.h
new file mode 100644
index 0000000..4b25670
--- /dev/null
+++ b/linden/indra/newview/llfloaterdisplayname.h
@@ -0,0 +1,48 @@
+/** 
+ * @file llfloaterdisplayname.h
+ *
+ * $LicenseInfo:firstyear=2009&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LLFLOATERDISPLAYNAME_H
+#define LLFLOATERDISPLAYNAME_H
+
+
+class LLFloaterDisplayName : public LLFloater
+{
+public:
+        LLFloaterDisplayName();
+        virtual ~LLFloaterDisplayName();
+        /* virtual */ BOOL postBuild();
+        /* virtual */ void onOpen();
+        static void show();
+        static void onSave(void* data);
+        static void onReset(void* data);
+        static void onCancel(void* data);
+
+private:
+        static LLFloaterDisplayName* sInstance;
+        void onCacheSetName(bool success, const std::string& reason, const LLSD& content);
+};
+
+
+#endif
diff --git a/linden/indra/newview/llfloaterfriends.cpp b/linden/indra/newview/llfloaterfriends.cpp
index 0b4610c..cf25e8e 100644
--- a/linden/indra/newview/llfloaterfriends.cpp
+++ b/linden/indra/newview/llfloaterfriends.cpp
@@ -39,6 +39,7 @@
 
 #include <sstream>
 
+#include "llavatarnamecache.h"
 #include "lldir.h"
 
 #include "llagent.h"
@@ -254,6 +255,24 @@ BOOL LLPanelFriends::addFriend(const LLUUID& agent_id)
 
         std::string fullname;
         BOOL have_name = gCacheName->getFullName(agent_id, fullname);
+        if (have_name)
+        {
+                if (LLAvatarNameCache::useDisplayNames() && !gSavedSettings.getBOOL("LegacyNamesForFriends"))
+                {
+                        LLAvatarName avatar_name;
+                        if (LLAvatarNameCache::get(agent_id, &avatar_name))
+                        {
+                                if (LLAvatarNameCache::useDisplayNames() == 1)
+                                {
+                                        fullname = avatar_name.mDisplayName;
+                                }
+                                else
+                                {
+                                        fullname = avatar_name.getNames();
+                                }
+                        }
+                }
+        }
         
         LLSD element;
         element["id"] = agent_id;
@@ -332,6 +351,24 @@ BOOL LLPanelFriends::updateFriendItem(const LLUUID& agent_id, const LLRelationsh
 
         std::string fullname;
         BOOL have_name = gCacheName->getFullName(agent_id, fullname);
+        if (have_name)
+        {
+                if (LLAvatarNameCache::useDisplayNames() && !gSavedSettings.getBOOL("LegacyNamesForFriends"))
+                {
+                        LLAvatarName avatar_name;
+                        if (LLAvatarNameCache::get(agent_id, &avatar_name))
+                        {
+                                if (LLAvatarNameCache::useDisplayNames() == 1)
+                                {
+                                        fullname = avatar_name.mDisplayName;
+                                }
+                                else
+                                {
+                                        fullname = avatar_name.getNames();
+                                }
+                        }
+                }
+        }
         
         // Name of the status icon to use
         std::string statusIcon;
@@ -790,6 +827,25 @@ void LLPanelFriends::onClickRemove(void* user_data)
                         std::string first, last;
                         if(gCacheName->getName(agent_id, first, last))
                         {
+                                if (LLAvatarNameCache::useDisplayNames() && !gSavedSettings.getBOOL("LegacyNamesForFriends"))
+                                {
+                                        LLAvatarName avatar_name;
+                                        if (LLAvatarNameCache::get(agent_id, &avatar_name))
+                                        {
+                                                // Always show "Display Name [Legacy Name]" for security reasons
+                                                first = avatar_name.getNames();
+                                                size_t i = first.find(" ");
+                                                if (i != std::string::npos)
+                                                {
+                                                        last = first.substr(i + 1);
+                                                        first = first.substr(0, i);
+                                                }
+                                                else
+                                                {
+                                                        last = "";
+                                                }
+                                        }
+                                }
                                 args["FIRST_NAME"] = first;
                                 args["LAST_NAME"] = last;       
                         }
@@ -854,6 +910,25 @@ void LLPanelFriends::confirmModifyRights(rights_map_t& ids, EGrantRevoke command
                         std::string first, last;
                         if(gCacheName->getName(agent_id, first, last))
                         {
+                                if (LLAvatarNameCache::useDisplayNames() && !gSavedSettings.getBOOL("LegacyNamesForFriends"))
+                                {
+                                        LLAvatarName avatar_name;
+                                        if (LLAvatarNameCache::get(agent_id, &avatar_name))
+                                        {
+                                                // Always show "Display Name [Legacy Name]" for security reasons
+                                                first = avatar_name.getNames();
+                                                size_t i = first.find(" ");
+                                                if (i != std::string::npos)
+                                                {
+                                                        last = first.substr(i + 1);
+                                                        first = first.substr(0, i);
+                                                }
+                                                else
+                                                {
+                                                        last = "";
+                                                }
+                                        }
+                                }
                                 args["FIRST_NAME"] = first;
                                 args["LAST_NAME"] = last;       
                         }
diff --git a/linden/indra/newview/llfloaternewim.cpp b/linden/indra/newview/llfloaternewim.cpp
index 48920c1..272cb53 100644
--- a/linden/indra/newview/llfloaternewim.cpp
+++ b/linden/indra/newview/llfloaternewim.cpp
@@ -38,10 +38,9 @@
 #include "lltabcontainer.h"
 #include "llimview.h"
 
-S32 COL_1_WIDTH = 200;
+S32 COL_1_WIDTH = 400;
 
 static std::string sOnlineDescriptor = "*";
-static std::string sNameFormat = "[FIRST] [LAST]";
 
 LLFloaterNewIM::LLFloaterNewIM()
 {
@@ -69,7 +68,6 @@ BOOL LLFloaterNewIM::postBuild()
                         llwarns << "LLUICtrlFactory::getNameListByName() returned NULL for 'user_list'" << llendl;
                 }
                 sOnlineDescriptor = getString("online_descriptor");
-                sNameFormat = getString("name_format");
                 setDefaultBtn("start_btn");
                 return TRUE;
         }       
@@ -135,11 +133,8 @@ void LLFloaterNewIM::addGroup(const LLUUID& uuid, void* data, BOOL bold, BOOL on
 
 void LLFloaterNewIM::addAgent(const LLUUID& uuid, void* data, BOOL online)
 {
-        std::string first, last;
-        gCacheName->getName(uuid, first, last);
-        LLUIString fullname = sNameFormat;
-        fullname.setArg("[FIRST]", first);
-        fullname.setArg("[LAST]", last);
+        std::string fullname;
+        gCacheName->getFullName(uuid, fullname);
 
         LLSD row;
         row["id"] = uuid;
@@ -184,13 +179,20 @@ void LLFloaterNewIM::onStart(void* userdata)
                 const LLScrollListCell* cell = item->getColumn(0);
                 std::string name(cell->getValue());
 
-                // *NOTE: Do a live detrmination of what type of session it
+                // *NOTE: Do a live determination of what type of session it
                 // should be. If we restrict the new im panel to online users,
                 // then we can remove some of this code.
                 EInstantMessage type;
                 EInstantMessage* t = (EInstantMessage*)item->getUserdata();
                 if(t) type = (*t);
                 else type = LLIMMgr::defaultIMTypeForAgent(item->getUUID());
+                if (type != IM_SESSION_GROUP_START)
+                {
+                        // Needed to avoid catching a display name, which would
+                        // make us use a wrong IM log file...
+                        gCacheName->getFullName(item->getUUID(), name);
+                }
+
                 gIMMgr->addSession(name, type, item->getUUID());
 
                 make_ui_sound("UISndStartIM");
diff --git a/linden/indra/newview/llfloaterregioninfo.cpp b/linden/indra/newview/llfloaterregioninfo.cpp
index d4ffe22..163c1ec 100644
--- a/linden/indra/newview/llfloaterregioninfo.cpp
+++ b/linden/indra/newview/llfloaterregioninfo.cpp
@@ -362,13 +362,7 @@ void LLFloaterRegionInfo::processRegionInfo(LLMessageSystem* msg)
         panel->childSetValue("object_bonus_spin", LLSD(object_bonus_factor) );

         panel->childSetValue("access_combo", LLSD(sim_access) );

 

-

-        // detect teen grid for maturity

-

-        U32 parent_estate_id;

-        msg->getU32("RegionInfo", "ParentEstateID", parent_estate_id);

-        BOOL teen_grid = (parent_estate_id == 5);  // *TODO add field to estate table and test that

-        panel->childSetEnabled("access_combo", gAgent.isGodlike() || (region && region->canManageEstate() && !teen_grid));

+        panel->childSetEnabled("access_combo", gAgent.isGodlike() || (region && region->canManageEstate() ));

         panel->setCtrlsEnabled(allow_modify);

         

         // RegionSettings PANEL

@@ -1650,16 +1644,9 @@ void LLPanelEstateInfo::onClickAddAllowedGroup(void* user_data)
                 return;

         }

 

-        LLNotification::Params params("ChangeLindenAccess");

+        LLNotification::Params params("PfftLindenCrap");

         params.functor(boost::bind(&LLPanelEstateInfo::addAllowedGroup, self, _1, _2));

-        if (isLindenEstate())

-        {

-                LLNotifications::instance().add(params);

-        }

-        else

-        {

-                LLNotifications::instance().forceResponse(params, 0);

-        }

+        LLNotifications::instance().forceResponse(params, 0);

 }

 

 bool LLPanelEstateInfo::addAllowedGroup(const LLSD& notification, const LLSD& response)

@@ -1837,16 +1824,6 @@ std::string all_estates_text()
         }

 }

 

-// static

-bool LLPanelEstateInfo::isLindenEstate()

-{

-        LLPanelEstateInfo* panel = LLFloaterRegionInfo::getPanelEstate();

-        if (!panel) return false;

-

-        U32 estate_id = panel->getEstateID();

-        return (estate_id <= ESTATE_LAST_LINDEN);

-}

-

 typedef std::vector<LLUUID> AgentOrGroupIDsVector;

 struct LLEstateAccessChangeInfo

 {

@@ -1898,14 +1875,7 @@ void LLPanelEstateInfo::addAllowedGroup2(LLUUID id, void* user_data)
         params.payload(payload)

                 .substitutions(args)

                 .functor(accessCoreConfirm);

-        if (isLindenEstate())

-        {

-                LLNotifications::instance().forceResponse(params, 0);

-        }

-        else

-        {

-                LLNotifications::instance().add(params);

-        }

+        LLNotifications::instance().add(params);

 }

 

 // static

@@ -1916,19 +1886,12 @@ void LLPanelEstateInfo::accessAddCore(U32 operation_flag, const std::string& dia
         payload["dialog_name"] = dialog_name;

         // agent id filled in after avatar picker

 

-        LLNotification::Params params("ChangeLindenAccess");

+        LLNotification::Params params("PfftLindenCrap");

         params.payload(payload)

                 .functor(accessAddCore2);

 

-        if (isLindenEstate())

-        {

-                LLNotifications::instance().add(params);

-        }

-        else

-        {

-                // same as clicking "OK"

-                LLNotifications::instance().forceResponse(params, 0);

-        }

+        // same as clicking "OK"

+        LLNotifications::instance().forceResponse(params, 0);

 }

 

 // static

@@ -2008,16 +1971,8 @@ void LLPanelEstateInfo::accessAddCore3(const std::vector<std::string>& names, co
                 .payload(change_info->asLLSD())

                 .functor(accessCoreConfirm);

 

-        if (isLindenEstate())

-        {

-                // just apply to this estate

-                LLNotifications::instance().forceResponse(params, 0);

-        }

-        else

-        {

-                // ask if this estate or all estates with this owner

-                LLNotifications::instance().add(params);

-        }

+        // ask if this estate or all estates with this owner

+        LLNotifications::instance().add(params);

 }

 

 // static

@@ -2044,20 +1999,12 @@ void LLPanelEstateInfo::accessRemoveCore(U32 operation_flag, const std::string&
                 payload["allowed_ids"].append(item->getUUID());

         }

         

-        LLNotification::Params params("ChangeLindenAccess");

+        LLNotification::Params params("PfftLindenCrap");

         params.payload(payload)

                 .functor(accessRemoveCore2);

 

-        if (isLindenEstate())

-        {

-                // warn on change linden estate

-                LLNotifications::instance().add(params);

-        }

-        else

-        {

-                // just proceed, as if clicking OK

-                LLNotifications::instance().forceResponse(params, 0);

-        }

+        // just proceed, as if clicking OK

+        LLNotifications::instance().forceResponse(params, 0);

 }

 

 // static

@@ -2070,21 +2017,12 @@ bool LLPanelEstateInfo::accessRemoveCore2(const LLSD& notification, const LLSD&
                 return false;

         }

 

-        // If Linden estate, can only apply to "this" estate, not all estates

-        // owned by NULL.

-        if (isLindenEstate())

-        {

-                accessCoreConfirm(notification, response);

-        }

-        else

-        {

-                LLSD args;

-                args["ALL_ESTATES"] = all_estates_text();

-                LLNotifications::instance().add(notification["payload"]["dialog_name"], 

-                                                                                args,

-                                                                                notification["payload"],

-                                                                                accessCoreConfirm);

-        }

+        LLSD args;

+        args["ALL_ESTATES"] = all_estates_text();

+        LLNotifications::instance().add(notification["payload"]["dialog_name"], 

+                                                                        args,

+                                                                        notification["payload"],

+                                                                        accessCoreConfirm);

         return false;

 }

 

@@ -2366,52 +2304,23 @@ BOOL LLPanelEstateInfo::sendUpdate()
 {

         llinfos << "LLPanelEsateInfo::sendUpdate()" << llendl;

 

-        LLNotification::Params params("ChangeLindenEstate");

-        params.functor(boost::bind(&LLPanelEstateInfo::callbackChangeLindenEstate, this, _1, _2));

-

-        if (getEstateID() <= ESTATE_LAST_LINDEN)

-        {

-                // trying to change reserved estate, warn

-                LLNotifications::instance().add(params);

-        }

-        else

+        // send the update

+        if (!commitEstateInfoCaps())

         {

-                // for normal estates, just make the change

-                LLNotifications::instance().forceResponse(params, 0);

+                // the caps method failed, try the old way

+                LLFloaterRegionInfo::nextInvoice();

+                commitEstateInfoDataserver();

         }

+        // we don't want to do this because we'll get it automatically from the sim

+        // after the spaceserver processes it

+//      else

+//      {

+//              // caps method does not automatically send this info

+//              LLFloaterRegionInfo::requestRegionInfo();

+//      }

         return TRUE;

 }

 

-bool LLPanelEstateInfo::callbackChangeLindenEstate(const LLSD& notification, const LLSD& response)

-{

-        S32 option = LLNotification::getSelectedOption(notification, response);

-        switch(option)

-        {

-        case 0:

-                // send the update

-                if (!commitEstateInfoCaps())

-                {

-                        // the caps method failed, try the old way

-                        LLFloaterRegionInfo::nextInvoice();

-                        commitEstateInfoDataserver();

-                }

-                // we don't want to do this because we'll get it automatically from the sim

-                // after the spaceserver processes it

-//              else

-//              {

-//                      // caps method does not automatically send this info

-//                      LLFloaterRegionInfo::requestRegionInfo();

-//              }

-                break;

-        case 1:

-        default:

-                // do nothing

-                break;

-        }

-        return false;

-}

-

-

 /*

 // Request = "getowner"

 // SParam[0] = "" (empty string)

@@ -2664,47 +2573,6 @@ void LLPanelEstateInfo::setAbuseEmailAddress(const std::string& address)
         childSetValue("abuse_email_address", LLSD(address));

 }

 

-void LLPanelEstateInfo::setAccessAllowedEnabled(bool enable_agent,

-                                                                                                bool enable_group,

-                                                                                                bool enable_ban)

-{

-        childSetEnabled("allow_resident_label", enable_agent);

-        childSetEnabled("allowed_avatar_name_list", enable_agent);

-        childSetVisible("allowed_avatar_name_list", enable_agent);

-        childSetEnabled("add_allowed_avatar_btn", enable_agent);

-        childSetEnabled("remove_allowed_avatar_btn", enable_agent);

-

-        // Groups

-        childSetEnabled("allow_group_label", enable_group);

-        childSetEnabled("allowed_group_name_list", enable_group);

-        childSetVisible("allowed_group_name_list", enable_group);

-        childSetEnabled("add_allowed_group_btn", enable_group);

-        childSetEnabled("remove_allowed_group_btn", enable_group);

-

-        // Ban

-        childSetEnabled("ban_resident_label", enable_ban);

-        childSetEnabled("banned_avatar_name_list", enable_ban);

-        childSetVisible("banned_avatar_name_list", enable_ban);

-        childSetEnabled("add_banned_avatar_btn", enable_ban);

-        childSetEnabled("remove_banned_avatar_btn", enable_ban);

-

-        // Update removal buttons if needed

-        if (enable_agent)

-        {

-                checkRemovalButton("allowed_avatar_name_list");

-        }

-

-        if (enable_group)

-        {

-                checkRemovalButton("allowed_group_name_list");

-        }

-

-        if (enable_ban)

-        {

-                checkRemovalButton("banned_avatar_name_list");

-        }

-}

-

 // static

 void LLPanelEstateInfo::callbackCacheName(

         const LLUUID& id,

@@ -3241,20 +3109,6 @@ bool LLDispatchEstateUpdateInfo::operator()(
                 panel->setSunHour(sun_hour);

         }

 

-        bool visible_from_mainland = (bool)(flags & REGION_FLAGS_EXTERNALLY_VISIBLE);

-        bool god = gAgent.isGodlike();

-        bool linden_estate = (estate_id <= ESTATE_LAST_LINDEN);

-

-        // If visible from mainland, disable the access allowed

-        // UI, as anyone can teleport there.

-        // However, gods need to be able to edit the access list for

-        // linden estates, regardless of visibility, to allow object

-        // and L$ transfers.

-        bool enable_agent = (!visible_from_mainland || (god && linden_estate));

-        bool enable_group = enable_agent;

-        bool enable_ban = !linden_estate;

-        panel->setAccessAllowedEnabled(enable_agent, enable_group, enable_ban);

-

         return true;

 }

 

diff --git a/linden/indra/newview/llfloaterregioninfo.h b/linden/indra/newview/llfloaterregioninfo.h
index ae0c993..f5e3d03 100644
--- a/linden/indra/newview/llfloaterregioninfo.h
+++ b/linden/indra/newview/llfloaterregioninfo.h
@@ -344,7 +344,6 @@ public:
 
         U32 getEstateID() const { return mEstateID; }
         void setEstateID(U32 estate_id) { mEstateID = estate_id; }
-        static bool isLindenEstate();
         
         const std::string getOwnerName() const;
         void setOwnerName(const std::string& name);
@@ -352,10 +351,6 @@ public:
         const std::string getAbuseEmailAddress() const;
         void setAbuseEmailAddress(const std::string& address);
 
-        // If visible from mainland, allowed agent and allowed groups
-        // are ignored, so must disable UI.
-        void setAccessAllowedEnabled(bool enable_agent, bool enable_group, bool enable_ban);
-
         // this must have the same function signature as
         // llmessage/llcachename.h:LLCacheNameCallback
         static void callbackCacheName(
@@ -367,8 +362,6 @@ public:
 
 protected:
         virtual BOOL sendUpdate();
-        // confirmation dialog callback
-        bool callbackChangeLindenEstate(const LLSD& notification, const LLSD& response);
 
         void commitEstateInfoDataserver();
         bool commitEstateInfoCaps();
diff --git a/linden/indra/newview/llfloatertools.cpp b/linden/indra/newview/llfloatertools.cpp
index 0cb35e3..2aed361 100644
--- a/linden/indra/newview/llfloatertools.cpp
+++ b/linden/indra/newview/llfloatertools.cpp
@@ -1259,7 +1259,9 @@ void LLFloaterTools::onClickLink(void* data)
         }
 
         S32 max_linked_prims = 0;
-        if(LLSelectMgr::getInstance()->getSelection()->getPrimaryObject()->usePhysics())
+
+        LLViewerObject* object = LLSelectMgr::getInstance()->getSelection()->getFirstRootObject();
+        if(object && object->usePhysics())
         {
                 //Physical - use phys prim limit
                 max_linked_prims = gHippoLimits->getMaxPhysLinkedPrims();
diff --git a/linden/indra/newview/llhoverview.cpp b/linden/indra/newview/llhoverview.cpp
index 5397f89..b2f4c22 100644
--- a/linden/indra/newview/llhoverview.cpp
+++ b/linden/indra/newview/llhoverview.cpp
@@ -253,10 +253,29 @@ void LLHoverView::updateText()
                         LLNameValue* lastname =  hit_object->getNVPair("LastName");
                         if (firstname && lastname)
                         {
+                                std::string complete_name = firstname->getString();
+                                complete_name += " ";
+                                complete_name += lastname->getString();
+
+                                if (LLAvatarNameCache::useDisplayNames())
+                                {
+                                        LLAvatarName avatar_name;
+                                        if (LLAvatarNameCache::get(hit_object->getID(), &avatar_name))
+                                        {
+                                                if (LLAvatarNameCache::useDisplayNames() == 1)
+                                                {
+                                                        complete_name = avatar_name.mDisplayName;
+                                                }
+                                                else
+                                                {
+                                                        complete_name = avatar_name.getNames();
+                                                }
+                                        }
+                                }
 // [RLVa:KB] - Checked: 2009-07-08 (RLVa-1.0.0e)
                                 if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES))
                                 {
-                                        line = RlvStrings::getAnonym(line.append(firstname->getString()).append(1, ' ').append(lastname->getString()));
+                                        line = RlvStrings::getAnonym(complete_name);
                                 }
                                 else
                                 {
diff --git a/linden/indra/newview/llimpanel.cpp b/linden/indra/newview/llimpanel.cpp
index d1e6139..cfe3996 100644
--- a/linden/indra/newview/llimpanel.cpp
+++ b/linden/indra/newview/llimpanel.cpp
@@ -106,6 +106,8 @@ LLVoiceChannel* LLVoiceChannel::sSuspendedVoiceChannel = NULL;
 
 BOOL LLVoiceChannel::sSuspended = FALSE;
 
+std::set<LLFloaterIMPanel*> LLFloaterIMPanel::sFloaterIMPanels;
+
 void session_starter_helper(
         const LLUUID& temp_session_id,
         const LLUUID& other_participant_id,
@@ -1108,6 +1110,7 @@ LLFloaterIMPanel::LLFloaterIMPanel(
         mFirstKeystrokeTimer(),
         mLastKeystrokeTimer()
 {
+        sFloaterIMPanels.insert(this);
         init(session_label);
 }
 
@@ -1149,6 +1152,7 @@ LLFloaterIMPanel::LLFloaterIMPanel(
 void LLFloaterIMPanel::init(const std::string& session_label)
 {
         mSessionLabel = session_label;
+        mProfileButtonEnabled = FALSE;
 
         std::string xml_filename;
         switch(mDialog)
@@ -1211,6 +1215,10 @@ void LLFloaterIMPanel::init(const std::string& session_label)
                                                                 FALSE);
 
         setTitle(mSessionLabel);
+        if (mProfileButtonEnabled)
+        {
+                lookupName();
+        }
 
         mInputEditor->setMaxTextLength(DB_IM_MSG_STR_LEN);
         // enable line history support for instant message bar
@@ -1253,9 +1261,32 @@ void LLFloaterIMPanel::init(const std::string& session_label)
         }
 }
 
+void LLFloaterIMPanel::lookupName()
+{
+        LLAvatarNameCache::get(mOtherParticipantUUID, boost::bind(&LLFloaterIMPanel::onAvatarNameLookup, _1, _2, this));
+}
+
+//static 
+void LLFloaterIMPanel::onAvatarNameLookup(const LLUUID& id, const LLAvatarName& avatar_name, void* user_data)
+{
+        LLFloaterIMPanel* self = (LLFloaterIMPanel*)user_data;
+
+        if (self && sFloaterIMPanels.count(self) != 0)
+        {
+                // Always show "Display Name [Legacy Name]" for security reasons
+                std::string title = avatar_name.getNames();
+                if (!title.empty())
+                {
+                        self->setTitle(title);
+                }
+        }
+}
+
 
 LLFloaterIMPanel::~LLFloaterIMPanel()
 {
+        sFloaterIMPanels.erase(this);
+
         delete mSpeakers;
         mSpeakers = NULL;
         
@@ -1550,8 +1581,9 @@ BOOL LLFloaterIMPanel::inviteToSession(const LLDynamicArray<LLUUID>& ids)
         return TRUE;
 }
 
-void LLFloaterIMPanel::addHistoryLine(const std::string &utf8msg, const LLColor4& color, bool log_to_file, const LLUUID& source, const std::string& name)
+void LLFloaterIMPanel::addHistoryLine(const std::string &utf8msg, const LLColor4& color, bool log_to_file, const LLUUID& source, const std::string& const_name)
 {
+        std::string name = const_name;
         // start tab flashing when receiving im for background session from user
         if (source != LLUUID::null)
         {
@@ -1602,6 +1634,21 @@ void LLFloaterIMPanel::addHistoryLine(const std::string &utf8msg, const LLColor4
                 }
                 else
                 {
+                        if (LLAvatarNameCache::useDisplayNames() && source != LLUUID::null)
+                        {
+                                LLAvatarName avatar_name;
+                                if (LLAvatarNameCache::get(source, &avatar_name))
+                                {
+                                        if (LLAvatarNameCache::useDisplayNames() == 1)
+                                        {
+                                                name = avatar_name.mDisplayName;
+                                        }
+                                        else
+                                        {
+                                                name = avatar_name.getNames();
+                                        }
+                                }
+                        }
                         // Convert the name to a hotlink and add to message.
                         const LLStyleSP &source_style = LLStyleMap::instance().lookupAgent(source);
                         mHistoryEditor->appendStyledText(name,false,prepend_newline,source_style);
@@ -1619,7 +1666,7 @@ void LLFloaterIMPanel::addHistoryLine(const std::string &utf8msg, const LLColor4
                 else
                         histstr = name + utf8msg;
 
-                LLLogChat::saveHistory(getTitle(),histstr);
+                LLLogChat::saveHistory(mSessionLabel, histstr);
         }
 
         if (!isInVisibleChain())
@@ -2168,6 +2215,21 @@ void LLFloaterIMPanel::sendMsg()
                                 {
                                         std::string history_echo;
                                         gAgent.buildFullname(history_echo);
+                                        if (LLAvatarNameCache::useDisplayNames())
+                                        {
+                                                LLAvatarName avatar_name;
+                                                if (LLAvatarNameCache::get(gAgent.getID(), &avatar_name))
+                                                {
+                                                        if (LLAvatarNameCache::useDisplayNames() == 1)
+                                                        {
+                                                                history_echo = avatar_name.mDisplayName;
+                                                        }
+                                                        else
+                                                        {
+                                                                history_echo = avatar_name.getNames();
+                                                        }
+                                                }
+                                        }
 
                                         // Look for IRC-style emotes here.
                                         std::string prefix = utf8_text.substr(0, 4);
diff --git a/linden/indra/newview/llimpanel.h b/linden/indra/newview/llimpanel.h
index ddcbdc7..b5a0165 100644
--- a/linden/indra/newview/llimpanel.h
+++ b/linden/indra/newview/llimpanel.h
@@ -33,6 +33,7 @@
 #ifndef LL_IMPANEL_H
 #define LL_IMPANEL_H
 
+#include "llavatarnamecache.h"
 #include "llfloater.h"
 #include "lllogchat.h"
 #include "lluuid.h"
@@ -194,6 +195,9 @@ public:
                                          EInstantMessage dialog);
         virtual ~LLFloaterIMPanel();
 
+        void lookupName();
+        static void onAvatarNameLookup(const LLUUID& id, const LLAvatarName& avatar_name, void* user_data);
+
         /*virtual*/ BOOL postBuild();
 
         // Check typing timeout timer.
@@ -365,6 +369,8 @@ private:
         typedef std::map<LLUUID, LLStyleSP> styleMap;
         static styleMap mStyleMap;
 
+        static std::set<LLFloaterIMPanel*> sFloaterIMPanels;
+
         typedef enum e_im_format
         {
                 IM_PANEL_PLAIN,
diff --git a/linden/indra/newview/llmanipscale.cpp b/linden/indra/newview/llmanipscale.cpp
index 268e431..b38abe4 100644
--- a/linden/indra/newview/llmanipscale.cpp
+++ b/linden/indra/newview/llmanipscale.cpp
@@ -1523,7 +1523,7 @@ void LLManipScale::renderSnapGuides(const LLBBox& bbox)
         F32 max_subdivisions = sGridMaxSubdivisionLevel;
         F32 grid_alpha = gSavedSettings.getF32("GridOpacity");
 
-        F32 max_point_on_scale_line = partToMaxScale(mManipPart, bbox);
+        F32 max_point_on_scale_line = llmin(partToMaxScale(mManipPart, bbox), LLWorld::getInstance()->getRegionWidthInMeters());
         LLVector3 drag_point = gAgent.getPosAgentFromGlobal(mDragPointGlobal);
 
         updateGridSettings();
diff --git a/linden/indra/newview/llnamelistctrl.cpp b/linden/indra/newview/llnamelistctrl.cpp
index e445df5..e30c129 100644
--- a/linden/indra/newview/llnamelistctrl.cpp
+++ b/linden/indra/newview/llnamelistctrl.cpp
@@ -39,6 +39,7 @@
 #include "llcachename.h"
 #include "llagent.h"
 #include "llinventory.h"
+#include "llviewercontrol.h"
 
 static LLRegisterWidget<LLNameListCtrl> r("name_list");
 
@@ -56,7 +57,8 @@ LLNameListCtrl::LLNameListCtrl(const std::string& name,
 :       LLScrollListCtrl(name, rect, cb, userdata, allow_multiple_selection,
                                          draw_border),
         mNameColumnIndex(name_column_index),
-        mAllowCallingCardDrop(FALSE)
+        mAllowCallingCardDrop(FALSE),
+        mUseDisplayNames(FALSE)
 {
         setToolTip(tooltip);
         LLNameListCtrl::sInstances.insert(this);
@@ -77,7 +79,7 @@ BOOL LLNameListCtrl::addNameItem(const LLUUID& agent_id, EAddPosition pos,
         //llinfos << "LLNameListCtrl::addNameItem " << agent_id << llendl;
 
         std::string fullname;
-        BOOL result = gCacheName->getFullName(agent_id, fullname);
+        BOOL result = getResidentName(agent_id, fullname);
 
         fullname.append(suffix);
 
@@ -164,7 +166,7 @@ BOOL LLNameListCtrl::addNameItem(LLScrollListItem* item, EAddPosition pos)
         //llinfos << "LLNameListCtrl::addNameItem " << item->getUUID() << llendl;
 
         std::string fullname;
-        BOOL result = gCacheName->getFullName(item->getUUID(), fullname);
+        BOOL result = getResidentName(item->getUUID(), fullname);
 
         LLScrollListCell* cell = (LLScrollListCell*)item->getColumn(mNameColumnIndex);
         ((LLScrollListText*)cell)->setText( fullname );
@@ -199,7 +201,7 @@ LLScrollListItem* LLNameListCtrl::addElement(const LLSD& value, EAddPosition pos
         else // normal resident
         {
                 std::string name;
-                if (gCacheName->getFullName(item->getUUID(), name))
+                if (getResidentName(item->getUUID(), name))
                 {
                         fullname = name;
                 }
@@ -346,6 +348,12 @@ LLView* LLNameListCtrl::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFacto
                 name_list->setAllowCallingCardDrop(allow_calling_card_drop);
         }
 
+        BOOL use_display_names;
+        if (node->getAttributeBOOL("use_display_names", use_display_names))
+        {
+                name_list->setUseDisplayNames(use_display_names);
+        }
+
         name_list->setScrollListParameters(node);
 
         name_list->initFromXML(node, parent);
@@ -456,5 +464,31 @@ LLView* LLNameListCtrl::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFacto
         return name_list;
 }
 
-
-
+bool LLNameListCtrl::getResidentName(const LLUUID& agent_id, std::string& fullname)
+{
+        std::string name;
+        if (gCacheName->getFullName(agent_id, name))
+        {
+                fullname = name;
+                if (mUseDisplayNames && LLAvatarNameCache::useDisplayNames() && !gSavedSettings.getBOOL("LegacyNamesForFriends"))
+                {
+                        LLAvatarName avatar_name;
+                        if (LLAvatarNameCache::get(agent_id, &avatar_name))
+                        {
+                                if (LLAvatarNameCache::useDisplayNames() == 1)
+                                {
+                                        fullname = avatar_name.mDisplayName;
+                                }
+                                else
+                                {
+                                        fullname = avatar_name.getNames();
+                                }
+                        }
+                }
+                return true;
+        }
+        else
+        {
+                return false;
+        }
+}
diff --git a/linden/indra/newview/llnamelistctrl.h b/linden/indra/newview/llnamelistctrl.h
index beb4ede..d6cf578 100644
--- a/linden/indra/newview/llnamelistctrl.h
+++ b/linden/indra/newview/llnamelistctrl.h
@@ -84,7 +84,12 @@ public:
 
         void setAllowCallingCardDrop(BOOL b) { mAllowCallingCardDrop = b; }
 
+        void setUseDisplayNames(BOOL b) { mUseDisplayNames = b; }
+
 private:
+        bool    getResidentName(const LLUUID& agent_id, std::string& fullname);
+        BOOL    mUseDisplayNames;
+
         static std::set<LLNameListCtrl*> sInstances;
         S32      mNameColumnIndex;
         BOOL     mAllowCallingCardDrop;
diff --git a/linden/indra/newview/llnetmap.cpp b/linden/indra/newview/llnetmap.cpp
index b9dc482..06257f0 100644
--- a/linden/indra/newview/llnetmap.cpp
+++ b/linden/indra/newview/llnetmap.cpp
@@ -36,6 +36,7 @@
 #include "llnetmap.h"
 
 #include "indra_constants.h"
+#include "llavatarnamecache.h"
 #include "llui.h"
 #include "llmath.h"             // clampf()
 #include "llfocusmgr.h"
@@ -640,7 +641,29 @@ BOOL LLNetMap::handleToolTip( S32 x, S32 y, std::string& msg, LLRect* sticky_rec
         {
                 msg.assign("");
                 std::string fullname;
-                if(mClosestAgentToCursor.notNull() && gCacheName->getFullName(mClosestAgentToCursor, fullname))
+                BOOL result = FALSE;
+                if (!LLAvatarNameCache::useDisplayNames())
+                {
+                        result = gCacheName->getFullName(mClosestAgentToCursor, fullname);
+                }
+                else
+                {
+                        LLAvatarName avatar_name;
+                        if (LLAvatarNameCache::get(mClosestAgentToCursor, &avatar_name))
+                        {
+                                result = TRUE;
+                                if (LLAvatarNameCache::useDisplayNames() == 1)
+                                {
+                                        fullname = avatar_name.mDisplayName;
+                                }
+                                else
+                                {
+                                        fullname = avatar_name.getNames(true);
+                                }
+                        }
+                }
+
+                if(mClosestAgentToCursor.notNull() && result)
                 {
 //                      msg.append(fullname);
 // [RLVa:KB] - Version: 1.23.4 | Checked: 2009-07-08 (RLVa-1.0.0e) | Modified: RLVa-0.2.0b
diff --git a/linden/indra/newview/lloverlaybar.cpp b/linden/indra/newview/lloverlaybar.cpp
index ed406e8..4e1d03e 100644
--- a/linden/indra/newview/lloverlaybar.cpp
+++ b/linden/indra/newview/lloverlaybar.cpp
@@ -38,7 +38,7 @@
 #include "lloverlaybar.h"
 
 #include "aoremotectrl.h"
-#include "llaudioengine.h"
+#include "kokuastreamingaudio.h"
 #include "llrender.h"
 #include "llagent.h"
 #include "llbutton.h"
@@ -438,17 +438,16 @@ void LLOverlayBar::toggleMusicPlay(void*)
         if (gOverlayBar->mMusicState != PLAYING)
         {
                 gOverlayBar->mMusicState = PLAYING; // desired state
-                if (gAudiop)
+                if (gAudioStream)
                 {
                         LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
                         if ( parcel )
                         {
                                 // this doesn't work properly when crossing parcel boundaries - even when the 
                                 // stream is stopped, it doesn't return the right thing - commenting out for now.
-        //                      if ( gAudiop->isInternetStreamPlaying() == 0 )
+        //                      if ( gAudioStream->isInternetStreamPlaying() == 0 )
                                 {
-                                        gAudiop->startInternetStream(parcel->getMusicURL());
-//awfixme                                       sTitleObserver.init(parcel->getMusicURL());
+                                        gAudioStream->startInternetStream(parcel->getMusicURL());
                                 }
                         }
                 }
@@ -456,9 +455,9 @@ void LLOverlayBar::toggleMusicPlay(void*)
         else
         {
                 gOverlayBar->mMusicState = STOPPED; // desired state
-                if (gAudiop)
+                if (gAudioStream)
                 {
-                        gAudiop->stopInternetStream();
+                        gAudioStream->stopInternetStream();
                 }
         }
 }
diff --git a/linden/indra/newview/llpanelavatar.cpp b/linden/indra/newview/llpanelavatar.cpp
index e47ae2a..6b3be29 100644
--- a/linden/indra/newview/llpanelavatar.cpp
+++ b/linden/indra/newview/llpanelavatar.cpp
@@ -416,6 +416,7 @@ BOOL LLPanelAvatarWeb::postBuild(void)
         childSetControlName("auto_load","AutoLoadWebProfiles");
 
         mWebBrowser = getChild<LLMediaCtrl>("profile_html");
+
         mWebBrowser->addObserver(this);
 
         // links open in internally 
@@ -490,7 +491,17 @@ void LLPanelAvatarWeb::refresh()
                 mNavigateTo = "";
         }
 }
+void LLPanelAvatarWeb::onVisibilityChange(BOOL new_visibility)
+{
+        LLPluginClassMedia::EPriority new_priority;
 
+        if (new_visibility)
+                new_priority = LLPluginClassMedia::PRIORITY_NORMAL;
+        else
+                new_priority = LLPluginClassMedia::PRIORITY_HIDDEN;
+
+        mWebBrowser->getMediaPlugin()->setPriority(new_priority);
+}
 
 void LLPanelAvatarWeb::enableControls(BOOL self)
 {       
@@ -1346,7 +1357,33 @@ void LLPanelAvatar::setAvatarID(const LLUUID &avatar_id, const std::string &name
                 {
                         name_edit->setText(name);
                 }
+                childSetVisible("name", TRUE);
+        }
+        LLNameEditor* complete_name_edit = getChild<LLNameEditor>("complete_name");
+        if (complete_name_edit)
+        {
+                if (LLAvatarNameCache::useDisplayNames())
+                {
+                        LLAvatarName avatar_name;
+                        if (LLAvatarNameCache::get(avatar_id, &avatar_name))
+                        {
+                                // Always show "Display Name [Legacy Name]" for security reasons
+                                complete_name_edit->setText(avatar_name.getNames());
+                        }
+                        else
+                        {
+                                complete_name_edit->setText(name_edit->getText());
+                                LLAvatarNameCache::get(avatar_id, boost::bind(&LLPanelAvatar::completeNameCallback, _1, _2, this));                     
+                        }
+                        childSetVisible("name", FALSE);
+                        childSetVisible("complete_name", TRUE);
+                }
+                else
+                {
+                        childSetVisible("complete_name", FALSE);
+                }
         }
+
 //      if (avatar_changed)
         {
                 // While we're waiting for data off the network, clear out the
@@ -1469,6 +1506,22 @@ void LLPanelAvatar::setAvatarID(const LLUUID &avatar_id, const std::string &name
         }
 }
 
+void LLPanelAvatar::completeNameCallback(const LLUUID& agent_id,
+                                                                                 const LLAvatarName& avatar_name,
+                                                                                 void *userdata)
+{
+        LLPanelAvatar* self = (LLPanelAvatar*)userdata;
+        if (!LLAvatarNameCache::useDisplayNames() || agent_id != self->mAvatarID)
+        {
+                return;
+        }
+        LLLineEditor* complete_name_edit = self->getChild<LLLineEditor>("complete_name");
+        if (complete_name_edit)
+        {
+                // Always show "Display Name [Legacy Name]" for security reasons
+                complete_name_edit->setText(avatar_name.getNames());
+        }
+}
 
 void LLPanelAvatar::resetGroupList()
 {
diff --git a/linden/indra/newview/llpanelavatar.h b/linden/indra/newview/llpanelavatar.h
index b687cd8..3a90196 100644
--- a/linden/indra/newview/llpanelavatar.h
+++ b/linden/indra/newview/llpanelavatar.h
@@ -33,6 +33,7 @@
 #ifndef LL_LLPANELAVATAR_H
 #define LL_LLPANELAVATAR_H
 
+#include "llavatarnamecache.h"
 #include "llpanel.h"
 #include "v3dmath.h"
 #include "lluuid.h"
@@ -76,7 +77,6 @@ public:
         /*virtual*/ void draw();
 
         LLPanelAvatar* getPanelAvatar() const { return mPanelAvatar; }
-
         void setDataRequested(bool requested) { mDataRequested = requested; }
         bool isDataRequested() const              { return mDataRequested; }
 
@@ -143,14 +143,15 @@ public:
         LLPanelAvatarWeb(const std::string& name, const LLRect& rect, LLPanelAvatar* panel_avatar);
         /*virtual*/ ~LLPanelAvatarWeb();
         /*virtual*/ BOOL        postBuild(void);
-
         /*virtual*/ void refresh();
+        /*virtual*/ void onVisibilityChange(BOOL new_visibility);
 
         void enableControls(BOOL own_avatar);
 
         void setWebURL(std::string url);
 
         void load(std::string url);
+
         static void onURLKeystroke(LLLineEditor* editor, void* data);
         static void onCommitLoad(LLUICtrl* ctrl, void* data);
         static void onCommitURL(LLUICtrl* ctrl, void* data);
@@ -335,6 +336,9 @@ private:
         static bool finishUnfreeze(const LLSD& notification, const LLSD& response);
 
         static void showProfileCallback(S32 option, void *userdata);
+        static void completeNameCallback(const LLUUID& agent_id,
+                                                                         const LLAvatarName& avatar_name,
+                                                                         void *userdata);
 
         static  void*   createPanelAvatar(void* data);
         static  void*   createFloaterAvatarInfo(void*   data);
diff --git a/linden/indra/newview/llpaneldirfind.cpp b/linden/indra/newview/llpaneldirfind.cpp
index 342ffec..719a7a0 100644
--- a/linden/indra/newview/llpaneldirfind.cpp
+++ b/linden/indra/newview/llpaneldirfind.cpp
@@ -62,6 +62,7 @@
 #include "lluictrlfactory.h"
 #include "llfloaterdirectory.h"
 #include "llpaneldirbrowser.h"
+#include "llpluginclassmedia.h"
 
 #include <boost/tokenizer.hpp>
 #if LL_WINDOWS
@@ -196,10 +197,17 @@ void LLPanelDirFind::draw()
 // virtual
 void LLPanelDirFind::onVisibilityChange(BOOL new_visibility)
 {
+        LLPluginClassMedia::EPriority new_priority;
         if (new_visibility)
         {
                 mFloaterDirectory->hideAllDetailPanels();
+                new_priority = LLPluginClassMedia::PRIORITY_NORMAL;
         }
+        else
+                new_priority = LLPluginClassMedia::PRIORITY_HIDDEN;
+
+        mWebBrowser->getMediaPlugin()->setPriority(new_priority);
+
         LLPanel::onVisibilityChange(new_visibility);
 }
 
diff --git a/linden/indra/newview/llpanelgeneral.cpp b/linden/indra/newview/llpanelgeneral.cpp
index fc6073a..70146ce 100644
--- a/linden/indra/newview/llpanelgeneral.cpp
+++ b/linden/indra/newview/llpanelgeneral.cpp
@@ -98,6 +98,9 @@ BOOL LLPanelGeneral::postBuild()
         childSetValue("mini_map_notify_chat", gSavedSettings.getBOOL("MiniMapNotifyChatRange"));
         childSetValue("mini_map_notify_sim", gSavedSettings.getBOOL("MiniMapNotifySimRange"));
 
+//      mDisplayNamesUsage =  gSavedSettings.getU32("DisplayNamesUsage");
+//      mLegacyNamesForFriends =  gSavedSettings.getBOOL("LegacyNamesForFriends");
+
         getChild<LLColorSwatchCtrl>("effect_color_swatch")->set(gSavedSettings.getColor4("EffectColor"));
 
         childSetValue("ui_scale_slider", gSavedSettings.getF32("UIScaleFactor"));
@@ -210,6 +213,8 @@ void LLPanelGeneral::apply()
 
 void LLPanelGeneral::cancel()
 {
+//      gSavedSettings.setU32("DisplayNamesUsage", mDisplayNamesUsage);
+//      gSavedSettings.setBOOL("LegacyNamesForFriends", mDisplayNamesUsage);
 }
 
 // static
diff --git a/linden/indra/newview/llpanelgeneral.h b/linden/indra/newview/llpanelgeneral.h
index e85fdf8..56cc3de 100644
--- a/linden/indra/newview/llpanelgeneral.h
+++ b/linden/indra/newview/llpanelgeneral.h
@@ -51,6 +51,9 @@ private:
         static void onClickResetUISize(void*);
         static void onClickGrid(void*);
         static void onLocationChanged(LLUICtrl* ctrl, void* data);
+
+        U32 mDisplayNamesUsage;
+        bool mLegacyNamesForFriends;
 };
 
 #endif
diff --git a/linden/indra/newview/llpanelgroupgeneral.cpp b/linden/indra/newview/llpanelgroupgeneral.cpp
index 6878f84..7ff25a7 100644
--- a/linden/indra/newview/llpanelgroupgeneral.cpp
+++ b/linden/indra/newview/llpanelgroupgeneral.cpp
@@ -561,9 +561,13 @@ bool LLPanelGroupGeneral::apply(std::string& mesg)
                 gIMMgr->saveIgnoreGroup();
         }
 
-        mCtrlReceiveNotices->resetDirty();      //resetDirty() here instead of in update because this is where the settings 
-    mCtrlListGroup->resetDirty();               //are actually being applied. onCommitUserOnly doesn't call updateChanged directly.
-        mCtrlReceiveChat->resetDirty();
+        // Make sure we update the group list in our contacts list and our IMs -- MC
+        if (gIMMgr)
+        {
+                // update the talk view
+                gIMMgr->refresh();
+        }
+        gAgent.fireEvent(new LLEvent(&gAgent, "new group"), "");
 
         mChanged = FALSE;
 
@@ -778,21 +782,14 @@ void LLPanelGroupGeneral::update(LLGroupChange gc)
                 {
                         mCtrlReceiveNotices->setEnabled(mAllowEdit);
                 }
+                mCtrlReceiveNotices->resetDirty();
         }
 
         if (mCtrlReceiveChat)
         {
                 mCtrlReceiveChat->setVisible(is_member);
                 mCtrlReceiveChat->setEnabled(TRUE);
-        }
-
-        if (mCtrlListGroup)
-        {
-                mCtrlListGroup->setVisible(is_member);
-                if (is_member)
-                {
-                        mCtrlListGroup->setEnabled(mAllowEdit);
-                }
+                mCtrlReceiveChat->resetDirty();
         }
 
 
diff --git a/linden/indra/newview/llstartup.cpp b/linden/indra/newview/llstartup.cpp
index 31647e9..9734a18 100644
--- a/linden/indra/newview/llstartup.cpp
+++ b/linden/indra/newview/llstartup.cpp
@@ -41,6 +41,7 @@
 #endif
 #include "llpluginclassmediaowner.h"
 #include "llviewermedia_streamingaudio.h"
+#include "kokuastreamingaudio.h"
 #include "llaudioengine.h"
 
 #ifdef LL_FMOD
@@ -681,19 +682,13 @@ bool idle_startup()
                                         delete gAudiop;
                                         gAudiop = NULL;
                                 }
-
-                                if (gAudiop)
-                                {
-                                        // if the audio engine hasn't set up its own preferred handler for streaming audio then set up the generic streaming audio implementation which uses media plugins
-                                        if (NULL == gAudiop->getStreamingAudioImpl())
-                                        {
-                                                LL_INFOS("AppInit") << "Using media plugins to render streaming audio" << LL_ENDL;
-                                                gAudiop->setStreamingAudioImpl(new LLStreamingAudio_MediaPlugins());
                         }
                 }
-                        }
-                }
-                
+
+
+                if (!gAudioStream)
+                        gAudioStream =  new KOKUAStreamingAudio(new LLStreamingAudio_MediaPlugins());
+
                 LL_INFOS("AppInit") << "Audio Engine Initialized." << LL_ENDL;
 
                 
@@ -877,7 +872,47 @@ bool idle_startup()
 
         if (STATE_LOGIN_CLEANUP == LLStartUp::getStartupState())
         {
+
                 LL_DEBUGS("AppInitStartupState") << "STATE_LOGIN_CLEANUP" << LL_ENDL;
+
+                gDisconnected = TRUE;
+
+                std::string cmd_line_grid_choice = gSavedSettings.getString("CmdLineGridChoice");
+                std::string cmd_line_login_uri = gSavedSettings.getLLSD("CmdLineLoginURI").asString();
+                if(!cmd_line_grid_choice.empty() && cmd_line_login_uri.empty())
+                {
+                        gHippoGridManager->setCurrentGrid(cmd_line_grid_choice);
+                }
+
+                gHippoGridManager->setCurrentGridAsConnected();
+                gHippoLimits->setLimits();
+
+                if (gHippoGridManager->getConnectedGrid()->isSecondLife())
+                {
+                        LLStartUp::setStartupState( STATE_LECTURE_PRIVACY );
+                        LLFirstUse::Privacy();
+                }
+                else
+                {               
+                        LLStartUp::setStartupState( STATE_PRIVACY_LECTURED );
+                }
+
+                return FALSE;
+
+        }
+
+        if (STATE_LECTURE_PRIVACY == LLStartUp::getStartupState())
+        {
+                LL_DEBUGS("AppInitStartupState") << "STATE_LECTURE_PRIVACY" << LL_ENDL;
+
+                //wait for the user to decide
+                ms_sleep(1);
+                return FALSE;
+        }
+
+        if (STATE_PRIVACY_LECTURED == LLStartUp::getStartupState())
+        {
+                LL_DEBUGS("AppInitStartupState") << "STATE_PRIVACY_LECTURED" << LL_ENDL;
                 //reset the values that could have come in from a slurl
                 if (!gLoginHandler.getWebLoginKey().isNull())
                 {
@@ -919,15 +954,9 @@ bool idle_startup()
                         gDebugInfo["LoginName"] = firstname + " " + lastname;   
                 }
 
-                std::string cmd_line_grid_choice = gSavedSettings.getString("CmdLineGridChoice");
-                std::string cmd_line_login_uri = gSavedSettings.getLLSD("CmdLineLoginURI").asString();
-                if(!cmd_line_grid_choice.empty() && cmd_line_login_uri.empty())
-                {
-                        gHippoGridManager->setCurrentGrid(cmd_line_grid_choice);
-                }
 
-                gHippoGridManager->setCurrentGridAsConnected();
-                gHippoLimits->setLimits();
+
+
                 // create necessary directories
                 // *FIX: these mkdir's should error check
                 gDirUtilp->setLindenUserDir(gHippoGridManager->getCurrentGridNick(), firstname, lastname);
@@ -2005,6 +2034,12 @@ bool idle_startup()
         
                         // Load stored cache if possible
             LLAppViewer::instance()->loadNameCache();
+
+                        // Start cache in not-running state until we figure out if we have
+                        // capabilities for display name lookup
+                        LLAvatarNameCache::initClass(false);
+                        LLAvatarNameCache::setUseDisplayNames(gSavedSettings.getU32("DisplayNamesUsage"));
+                        LLAvatarName::sOmitResidentAsLastName = (bool)gSavedSettings.getBOOL("OmitResidentAsLastName");
                 }
 
                 // *Note: this is where gWorldMap used to be initialized.
@@ -3772,6 +3807,8 @@ std::string LLStartUp::startupStateToString(EStartupState state)
                 RTNENUM( STATE_LOGIN_SHOW );
                 RTNENUM( STATE_LOGIN_WAIT );
                 RTNENUM( STATE_LOGIN_CLEANUP );
+                RTNENUM( STATE_LECTURE_PRIVACY );
+                RTNENUM( STATE_PRIVACY_LECTURED );
                 RTNENUM( STATE_LOGIN_VOICE_LICENSE );
                 RTNENUM( STATE_UPDATE_CHECK );
                 RTNENUM( STATE_LOGIN_AUTH_INIT );
diff --git a/linden/indra/newview/llstartup.h b/linden/indra/newview/llstartup.h
index 08862e6..3fe8daa 100644
--- a/linden/indra/newview/llstartup.h
+++ b/linden/indra/newview/llstartup.h
@@ -49,7 +49,9 @@ typedef enum {
         STATE_BROWSER_INIT,             // Initialize web browser for login screen
         STATE_LOGIN_SHOW,                               // Show login screen
         STATE_LOGIN_WAIT,                               // Wait for user input at login screen
-        STATE_LOGIN_CLEANUP,                    // Get rid of login screen and start login
+        STATE_LOGIN_CLEANUP,                    // lecture about privacy
+        STATE_LECTURE_PRIVACY,                  //   wait until the lecture was read
+        STATE_PRIVACY_LECTURED,                 // Get rid of login screen and start login
         STATE_LOGIN_VOICE_LICENSE,              // Show license agreement for using voice
         STATE_UPDATE_CHECK,                             // Wait for user at a dialog box (updates, term-of-service, etc)
         STATE_LOGIN_AUTH_INIT,                  // Start login to SL servers
diff --git a/linden/indra/newview/lltexlayer.cpp b/linden/indra/newview/lltexlayer.cpp
index c8e1298..ceef28b 100644
--- a/linden/indra/newview/lltexlayer.cpp
+++ b/linden/indra/newview/lltexlayer.cpp
@@ -213,6 +213,7 @@ BOOL LLTexLayerSetBuffer::needsRender()
         LLVOAvatar* avatar = mTexLayerSet->getAvatar();
         BOOL upload_now = needsUploadNow();
         BOOL needs_update = (mNeedsUpdate || upload_now) && !avatar->mAppearanceAnimating;
+
         if (needs_update)
         {
                 BOOL invalid_skirt = avatar->getBakedTE(mTexLayerSet) == TEX_SKIRT_BAKED && !avatar->isWearingWearableType(WT_SKIRT);
@@ -275,16 +276,16 @@ BOOL LLTexLayerSetBuffer::render()
                         }
                         else
                         {
-                                //                              mUploadPending = FALSE;//see...
-                                //                              mNeedsUpload = FALSE;//     ...below...
+                                //mUploadPending = FALSE;//see...
+                                //mNeedsUpload = FALSE;//     ...below...
                                 LLVOAvatar*     avatar = mTexLayerSet->getAvatar();
                                 if (avatar)
                                 {
                                         avatar->setNewBakedTexture(avatar->getBakedTE(mTexLayerSet), IMG_INVISIBLE);
                                         llinfos << "Invisible baked texture set for " << mTexLayerSet->getBodyRegion() << llendl;
                                 }
-                                readBackAndUpload();    //... here: Opensim is not happy if we don't
-                                                        //TODO: find out if SL is happy if we do
+                                readBackAndUpload();   //... here: Opensim is not happy if we don't
+                                //TODO: find out if SL is happy if we do
                         }
                 }
         }
@@ -350,12 +351,11 @@ void LLTexLayerSetBuffer::readBackAndUpload()
         // writes into baked_color_data
         const char* comment_text = NULL;
 
-        S32 baked_image_components = 5; // red green blue bump clothing
+        S32 baked_image_components =  5; // red green blue bump clothing
         LLPointer<LLImageRaw> baked_image = new LLImageRaw( mWidth, mHeight, baked_image_components );
         U8* baked_image_data = baked_image->getData();
         
         comment_text = LINDEN_J2C_COMMENT_PREFIX "RGBHM"; // 5 channels: rgb, heightfield/alpha, mask
-
         S32 i = 0;
         for (S32 u = 0; u < mWidth; u++)
         {
@@ -492,7 +492,7 @@ void LLTexLayerSetBuffer::onTextureUploadComplete(const LLUUID& uuid, void* user
                                 avatar->setNewBakedTexture(baked_te, uuid);
                         }
                         else
-                        {       
+                        {
                                 ++failures;
                                 llinfos << "Baked upload failed (attempt " << failures << "/" << MAX_BAKE_UPLOAD_ATTEMPTS << "), ";
                                 if (failures >= MAX_BAKE_UPLOAD_ATTEMPTS)
@@ -1412,7 +1412,7 @@ BOOL LLTexLayer::render( S32 x, S32 y, S32 width, S32 height )
 
                                         LLTexUnit::eTextureAddressMode old_mode = image_gl->getAddressMode();
                                         
-                                        gGL.getTexUnit(0)->bind(image_gl);
+                                        gGL.getTexUnit(0)->bind(image_gl, TRUE);
                                         gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
 
                                         gl_rect_2d_simple_tex( width, height );
@@ -1430,7 +1430,7 @@ BOOL LLTexLayer::render( S32 x, S32 y, S32 width, S32 height )
                         LLImageGL* image_gl = gTexStaticImageList.getImageGL( getInfo()->mStaticImageFileName, getInfo()->mStaticImageIsMask );
                         if( image_gl )
                         {
-                                gGL.getTexUnit(0)->bind(image_gl);
+                                gGL.getTexUnit(0)->bind(image_gl, TRUE);
                                 gl_rect_2d_simple_tex( width, height );
                                 gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
                         }
@@ -1656,7 +1656,7 @@ BOOL LLTexLayer::renderAlphaMasks( S32 x, S32 y, S32 width, S32 height, LLColor4
 
                                         LLTexUnit::eTextureAddressMode old_mode = image_gl->getAddressMode();
                                         
-                                        gGL.getTexUnit(0)->bind(image_gl);
+                                        gGL.getTexUnit(0)->bind(image_gl, TRUE);
                                         gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
 
                                         gl_rect_2d_simple_tex( width, height );
@@ -1678,7 +1678,7 @@ BOOL LLTexLayer::renderAlphaMasks( S32 x, S32 y, S32 width, S32 height, LLColor4
                                         ( (image_gl->getComponents() == 1) && getInfo()->mStaticImageIsMask ) )
                                 {
                                         LLGLSNoAlphaTest gls_no_alpha_test;
-                                        gGL.getTexUnit(0)->bind(image_gl);
+                                        gGL.getTexUnit(0)->bind(image_gl, TRUE);
                                         gl_rect_2d_simple_tex( width, height );
                                         gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
                                 }
@@ -2146,7 +2146,7 @@ BOOL LLTexLayerParamAlpha::render( S32 x, S32 y, S32 width, S32 height )
                                 }
 
                                 LLGLSNoAlphaTest gls_no_alpha_test;
-                                gGL.getTexUnit(0)->bind(mCachedProcessedImageGL);
+                                gGL.getTexUnit(0)->bind(mCachedProcessedImageGL, TRUE);
                                 gl_rect_2d_simple_tex( width, height );
                                 gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
                                 stop_glerror();
diff --git a/linden/indra/newview/lltexturecache.cpp b/linden/indra/newview/lltexturecache.cpp
index 4679137..2e7d585 100644
--- a/linden/indra/newview/lltexturecache.cpp
+++ b/linden/indra/newview/lltexturecache.cpp
@@ -736,9 +736,6 @@ void LLTextureCacheWorker::endWork(S32 param, bool aborted)
 
 LLTextureCache::LLTextureCache(bool threaded)
         : LLWorkerThread("TextureCache", threaded),
-          mWorkersMutex(NULL),
-          mHeaderMutex(NULL),
-          mListMutex(NULL),
           mHeaderAPRFile(NULL),
           mReadOnly(FALSE),
           mTexturesSizeTotal(0),
@@ -1543,7 +1540,7 @@ bool LLTextureCache::readComplete(handle_t handle, bool abort)
                 }
         }
 
-        unlockWorkers();
+        unlockWorkers();
 
         if (delete_worker) worker->scheduleDelete();
 
diff --git a/linden/indra/newview/lltexturecache.h b/linden/indra/newview/lltexturecache.h
index c859b9a..56b4c4f 100644
--- a/linden/indra/newview/lltexturecache.h
+++ b/linden/indra/newview/lltexturecache.h
@@ -139,9 +139,6 @@ protected:
         std::string getTextureFileName(const LLUUID& id);
         void addCompleted(Responder* responder, bool success);
         
-protected:
-        //void setFileAPRPool(apr_pool_t* pool) { mFileAPRPool = pool ; }
-
 private:
         void setDirNames(ELLPath location);
         void readHeaderCache();
diff --git a/linden/indra/newview/lltexturefetch.cpp b/linden/indra/newview/lltexturefetch.cpp
index f93a574..072af25 100644
--- a/linden/indra/newview/lltexturefetch.cpp
+++ b/linden/indra/newview/lltexturefetch.cpp
@@ -428,7 +428,6 @@ LLTextureFetchWorker::LLTextureFetchWorker(LLTextureFetch* fetcher,
           mRetryAttempt(0),
           mActiveCount(0),
           mGetStatus(0),
-          mWorkMutex(NULL),
           mFirstPacket(0),
           mLastPacket(-1),
           mTotalPackets(0),
@@ -1540,8 +1539,6 @@ LLTextureFetch::LLTextureFetch(LLTextureCache* cache, LLImageDecodeThread* image
           mDebugPause(FALSE),
           mPacketCount(0),
           mBadPacketCount(0),
-          mQueueMutex(getAPRPool()),
-          mNetworkQueueMutex(getAPRPool()),
           mTextureCache(cache),
           mImageDecodeThread(imagedecodethread),
           mTextureBandwidth(0),
diff --git a/linden/indra/newview/lltoolpie.cpp b/linden/indra/newview/lltoolpie.cpp
index 296d1bb..34735a3 100644
--- a/linden/indra/newview/lltoolpie.cpp
+++ b/linden/indra/newview/lltoolpie.cpp
@@ -645,8 +645,6 @@ BOOL LLToolPie::handleHover(S32 x, S32 y, MASK mask)
         }
         */
 
-        
-        gViewerWindow->getWindow()->setCursor(UI_CURSOR_ARROW);
 
         LLViewerObject *object = NULL;
         LLViewerObject *parent = NULL;
@@ -697,9 +695,14 @@ BOOL LLToolPie::handleHover(S32 x, S32 y, MASK mask)
                 {
                         gViewerWindow->getWindow()->setCursor(UI_CURSOR_HAND);
                 }
+                else
+                {
+                        gViewerWindow->getWindow()->setCursor(UI_CURSOR_ARROW);
+                }
         }
         else
         {
+                gViewerWindow->getWindow()->setCursor(UI_CURSOR_ARROW);
                 // We need to clear media hover flag
                 if (LLViewerMediaFocus::getInstance()->getMouseOverFlag())
                 {
diff --git a/linden/indra/newview/llvieweraudio.cpp b/linden/indra/newview/llvieweraudio.cpp
index 91e7ce5..d465177 100644
--- a/linden/indra/newview/llvieweraudio.cpp
+++ b/linden/indra/newview/llvieweraudio.cpp
@@ -33,6 +33,7 @@
 #include "llviewerprecompiledheaders.h"
 
 #include "llaudioengine.h"
+#include "kokuastreamingaudio.h"
 #include "llagent.h"
 #include "llappviewer.h"
 #include "llvieweraudio.h"
@@ -46,69 +47,71 @@
 
 void init_audio() 
 {
-        if (!gAudiop) 
+        if (gAudiop) 
         {
-                llwarns << "Failed to create an appropriate Audio Engine" << llendl;
-                return;
+                LLVector3d lpos_global = gAgent.getCameraPositionGlobal();
+                LLVector3 lpos_global_f;
+        
+                lpos_global_f.setVec(lpos_global);
+                                                
+                gAudiop->setListener(lpos_global_f,
+                                                        LLVector3::zero,        // LLViewerCamera::getInstance()->getVelocity(),    // !!! BUG need to replace this with smoothed velocity!
+                                                        LLViewerCamera::getInstance()->getUpAxis(),
+                                                        LLViewerCamera::getInstance()->getAtAxis());
+        
+        // load up our initial set of sounds we'll want so they're in memory and ready to be played
+        
+                bool mute_audio = gSavedSettings.getBOOL("MuteAudio");
+        
+                if (!mute_audio && FALSE == gSavedSettings.getBOOL("NoPreload"))
+                {
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndAlert")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndBadKeystroke")));
+                        //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndChatFromObject")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndClick")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndClickRelease")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndHealthReductionF")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndHealthReductionM")));
+                        //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndIncomingChat")));
+                        //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndIncomingIM")));
+                        //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndInvApplyToObject")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndInvalidOp")));
+                        //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndInventoryCopyToInv")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndMoneyChangeDown")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndMoneyChangeUp")));
+                        //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndObjectCopyToInv")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndObjectCreate")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndObjectDelete")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndObjectRezIn")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndObjectRezOut")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuAppear")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuHide")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight0")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight1")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight2")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight3")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight4")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight5")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight6")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight7")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndSnapshot")));
+                        //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndStartAutopilot")));
+                        //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndStartFollowpilot")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndStartIM")));
+                        //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndStopAutopilot")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndTeleportOut")));
+                        //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndTextureApplyToObject")));
+                        //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndTextureCopyToInv")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndTyping")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndWindowClose")));
+                        gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndWindowOpen")));
+                }
         }
-        LLVector3d lpos_global = gAgent.getCameraPositionGlobal();
-        LLVector3 lpos_global_f;
-
-        lpos_global_f.setVec(lpos_global);
-                                        
-        gAudiop->setListener(lpos_global_f,
-                                                  LLVector3::zero,      // LLViewerCamera::getInstance()->getVelocity(),    // !!! BUG need to replace this with smoothed velocity!
-                                                  LLViewerCamera::getInstance()->getUpAxis(),
-                                                  LLViewerCamera::getInstance()->getAtAxis());
-
-// load up our initial set of sounds we'll want so they're in memory and ready to be played
-
-        bool mute_audio = gSavedSettings.getBOOL("MuteAudio");
-
-        if (!mute_audio && FALSE == gSavedSettings.getBOOL("NoPreload"))
+        else
         {
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndAlert")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndBadKeystroke")));
-                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndChatFromObject")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndClick")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndClickRelease")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndHealthReductionF")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndHealthReductionM")));
-                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndIncomingChat")));
-                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndIncomingIM")));
-                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndInvApplyToObject")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndInvalidOp")));
-                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndInventoryCopyToInv")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndMoneyChangeDown")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndMoneyChangeUp")));
-                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndObjectCopyToInv")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndObjectCreate")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndObjectDelete")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndObjectRezIn")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndObjectRezOut")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuAppear")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuHide")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight0")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight1")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight2")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight3")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight4")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight5")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight6")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight7")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndSnapshot")));
-                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndStartAutopilot")));
-                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndStartFollowpilot")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndStartIM")));
-                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndStopAutopilot")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndTeleportOut")));
-                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndTextureApplyToObject")));
-                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndTextureCopyToInv")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndTyping")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndWindowClose")));
-                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndWindowOpen")));
+                llwarns << "Failed to create an appropriate Audio Engine" << llendl;
+                return;
         }
-
         audio_update_volume(true);
 }
 
@@ -158,12 +161,12 @@ void audio_update_volume(bool force_update)
         }
 
         // Streaming Music
-        if (gAudiop) 
+        if (gAudioStream) 
         {               
                 F32 music_volume = gSavedSettings.getF32("AudioLevelMusic");
                 BOOL music_muted = gSavedSettings.getBOOL("MuteMusic");
                 music_volume = mute_volume * master_volume * (music_volume*music_volume);
-                gAudiop->setInternetStreamGain ( music_muted ? 0.f : music_volume );
+                gAudioStream->setInternetStreamGain ( music_muted ? 0.f : music_volume );
         
         }
 
diff --git a/linden/indra/newview/llviewercontrol.cpp b/linden/indra/newview/llviewercontrol.cpp
index 3675072..572f64a 100644
--- a/linden/indra/newview/llviewercontrol.cpp
+++ b/linden/indra/newview/llviewercontrol.cpp
@@ -38,8 +38,11 @@
 #include "indra_constants.h"
 
 // For Listeners
-#include "llaudioengine.h"
+// #include "llaudioengine.h"
+#include "kokuastreamingaudio.h"
 #include "llagent.h"
+#include "llavatarnamecache.h"
+#include "llcallingcard.h"
 #include "llconsole.h"
 #include "lldrawpoolterrain.h"
 #include "llflexibleobject.h"
@@ -310,7 +313,7 @@ static bool handleJoystickChanged(const LLSD& newvalue)
 
 static bool handleAudioStreamMusicChanged(const LLSD& newvalue)
 {
-        if (gAudiop)
+        if (gAudioStream)
         {
                 if ( newvalue.asBoolean() )
                 {
@@ -319,15 +322,15 @@ static bool handleAudioStreamMusicChanged(const LLSD& newvalue)
                         {
                                 // if stream is already playing, don't call this
                                 // otherwise music will briefly stop
-                                if ( !gAudiop->isInternetStreamPlaying() )
+                                if ( !gAudioStream->isInternetStreamPlaying() )
                                 {
-                                        gAudiop->startInternetStream(LLViewerParcelMgr::getInstance()->getAgentParcel()->getMusicURL());
+                                        gAudioStream->startInternetStream(LLViewerParcelMgr::getInstance()->getAgentParcel()->getMusicURL());
                                 }
                         }
                 }
                 else
                 {
-                        gAudiop->stopInternetStream();
+                        gAudioStream->stopInternetStream();
                 }
         }
         return true;
@@ -425,6 +428,28 @@ static bool handleAuditTextureChanged(const LLSD& newvalue)
         return true;
 }
 
+static bool handleDisplayNamesUsageChanged(const LLSD& newvalue)
+{
+        LLAvatarNameCache::setUseDisplayNames((U32)newvalue.asInteger());
+        LLVOAvatar::invalidateNameTags();
+        LLAvatarTracker::instance().dirtyBuddies();
+        return true;
+}
+
+static bool handleOmitResidentAsLastNameChanged(const LLSD& newvalue)
+{
+        LLAvatarName::sOmitResidentAsLastName =(bool)newvalue.asBoolean();
+        LLVOAvatar::invalidateNameTags();
+        LLAvatarTracker::instance().dirtyBuddies();
+        return true;
+}
+
+static bool handleLegacyNamesForFriendsChanged(const LLSD& newvalue)
+{
+        LLAvatarTracker::instance().dirtyBuddies();
+        return true;
+}
+
 static bool handleRenderDebugGLChanged(const LLSD& newvalue)
 {
         gDebugGL = newvalue.asBoolean();
@@ -572,6 +597,9 @@ void settings_setup_listeners()
         gSavedSettings.getControl("AudioLevelRolloff")->getSignal()->connect(boost::bind(&handleAudioVolumeChanged, _1));
         gSavedSettings.getControl("AudioStreamingMusic")->getSignal()->connect(boost::bind(&handleAudioStreamMusicChanged, _1));
         gSavedSettings.getControl("AuditTexture")->getSignal()->connect(boost::bind(&handleAuditTextureChanged, _1));
+        gSavedSettings.getControl("DisplayNamesUsage")->getSignal()->connect(boost::bind(&handleDisplayNamesUsageChanged, _1));
+        gSavedSettings.getControl("OmitResidentAsLastName")->getSignal()->connect(boost::bind(&handleOmitResidentAsLastNameChanged, _1));
+        gSavedSettings.getControl("LegacyNamesForFriends")->getSignal()->connect(boost::bind(&handleLegacyNamesForFriendsChanged, _1));
         gSavedSettings.getControl("MuteAudio")->getSignal()->connect(boost::bind(&handleAudioVolumeChanged, _1));
         gSavedSettings.getControl("MuteMusic")->getSignal()->connect(boost::bind(&handleAudioVolumeChanged, _1));
         gSavedSettings.getControl("MuteMedia")->getSignal()->connect(boost::bind(&handleAudioVolumeChanged, _1));
diff --git a/linden/indra/newview/llviewerdisplayname.cpp b/linden/indra/newview/llviewerdisplayname.cpp
new file mode 100644
index 0000000..6a7cab3
--- /dev/null
+++ b/linden/indra/newview/llviewerdisplayname.cpp
@@ -0,0 +1,208 @@
+/** 
+ * @file llviewerdisplayname.cpp
+ * @brief Wrapper for display name functionality
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "llviewerdisplayname.h"
+
+// viewer includes
+#include "llagent.h"
+#include "llviewerregion.h"
+#include "llvoavatar.h"
+
+// library includes
+#include "llavatarnamecache.h"
+#include "llhttpclient.h"
+#include "llhttpnode.h"
+#include "llnotifications.h"
+#include "llui.h"                                       // getLanguage()
+
+namespace LLViewerDisplayName
+{
+        // Fired when viewer receives server response to display name change
+        set_name_signal_t sSetDisplayNameSignal;
+
+        // Fired when there is a change in the agent's name
+        name_changed_signal_t sNameChangedSignal;
+
+        void addNameChangedCallback(const name_changed_signal_t::slot_type& cb) 
+        { 
+                sNameChangedSignal.connect(cb); 
+        }
+
+}
+
+class LLSetDisplayNameResponder : public LLHTTPClient::Responder
+{
+public:
+        // only care about errors
+        /*virtual*/ void error(U32 status, const std::string& reason)
+        {
+                LLViewerDisplayName::sSetDisplayNameSignal(false, "", LLSD());
+                LLViewerDisplayName::sSetDisplayNameSignal.disconnect_all_slots();
+        }
+};
+
+void LLViewerDisplayName::set(const std::string& display_name, const set_name_slot_t& slot)
+{
+        // TODO: simple validation here
+
+        LLViewerRegion* region = gAgent.getRegion();
+        llassert(region);
+        std::string cap_url = region->getCapability("SetDisplayName");
+        if (cap_url.empty())
+        {
+                // this server does not support display names, report error
+                slot(false, "unsupported", LLSD());
+                return;
+        }
+
+        // People API can return localized error messages.  Indicate our
+        // language preference via header.
+        LLSD headers;
+        headers["Accept-Language"] = LLUI::getLanguage();
+
+        // People API requires both the old and new value to change a variable.
+        // Our display name will be in cache before the viewer's UI is available
+        // to request a change, so we can use direct lookup without callback.
+        LLAvatarName av_name;
+        if (!LLAvatarNameCache::get( gAgent.getID(), &av_name))
+        {
+                slot(false, "name unavailable", LLSD());
+                return;
+        }
+
+        // People API expects array of [ "old value", "new value" ]
+        LLSD change_array = LLSD::emptyArray();
+        change_array.append(av_name.mDisplayName);
+        change_array.append(display_name);
+        
+        llinfos << "Set name POST to " << cap_url << llendl;
+
+        // Record our caller for when the server sends back a reply
+        sSetDisplayNameSignal.connect(slot);
+        
+        // POST the requested change.  The sim will not send a response back to
+        // this request directly, rather it will send a separate message after it
+        // communicates with the back-end.
+        LLSD body;
+        body["display_name"] = change_array;
+        LLHTTPClient::post(cap_url, body, new LLSetDisplayNameResponder, headers);
+}
+
+class LLSetDisplayNameReply : public LLHTTPNode
+{
+        LOG_CLASS(LLSetDisplayNameReply);
+public:
+        /*virtual*/ void post(
+                LLHTTPNode::ResponsePtr response,
+                const LLSD& context,
+                const LLSD& input) const
+        {
+                LLSD body = input["body"];
+
+                S32 status = body["status"].asInteger();
+                bool success = (status == 200);
+                std::string reason = body["reason"].asString();
+                LLSD content = body["content"];
+
+                llinfos << "status " << status << " reason " << reason << llendl;
+
+                // If viewer's concept of display name is out-of-date, the set request
+                // will fail with 409 Conflict.  If that happens, fetch up-to-date
+                // name information.
+                if (status == 409)
+                {
+                        LLUUID agent_id = gAgent.getID();
+                        // Flush stale data
+                        LLAvatarNameCache::erase( agent_id );
+                        // Queue request for new data
+                        LLAvatarName ignored;
+                        LLAvatarNameCache::get( agent_id, &ignored );
+                        // Kill name tag, as it is wrong
+                        LLVOAvatar::invalidateNameTag( agent_id );
+                }
+
+                // inform caller of result
+                LLViewerDisplayName::sSetDisplayNameSignal(success, reason, content);
+                LLViewerDisplayName::sSetDisplayNameSignal.disconnect_all_slots();
+        }
+};
+
+
+class LLDisplayNameUpdate : public LLHTTPNode
+{
+        /*virtual*/ void post(
+                LLHTTPNode::ResponsePtr response,
+                const LLSD& context,
+                const LLSD& input) const
+        {
+                LLSD body = input["body"];
+                LLUUID agent_id = body["agent_id"];
+                std::string old_display_name = body["old_display_name"];
+                // By convention this record is called "agent" in the People API
+                LLSD name_data = body["agent"];
+
+                // Inject the new name data into cache
+                LLAvatarName av_name;
+                av_name.fromLLSD( name_data );
+
+                llinfos << "name-update now " << LLDate::now()
+                        << " next_update " << LLDate(av_name.mNextUpdate)
+                        << llendl;
+
+                // Name expiration time may be provided in headers, or we may use a
+                // default value
+                // *TODO: get actual headers out of ResponsePtr
+                //LLSD headers = response->mHeaders;
+                LLSD headers;
+                av_name.mExpires = 
+                        LLAvatarNameCache::nameExpirationFromHeaders(headers);
+
+                LLAvatarNameCache::insert(agent_id, av_name);
+
+                // force name tag to update
+                LLVOAvatar::invalidateNameTag(agent_id);
+
+                LLSD args;
+                args["OLD_NAME"] = old_display_name;
+                args["SLID"] = av_name.mUsername;
+                args["NEW_NAME"] = av_name.mDisplayName;
+                LLNotifications::instance().add("DisplayNameUpdate", args);
+                if (agent_id == gAgent.getID())
+                {
+                        LLViewerDisplayName::sNameChangedSignal();
+                }
+        }
+};
+
+LLHTTPRegistration<LLSetDisplayNameReply>
+    gHTTPRegistrationMessageSetDisplayNameReply(
+                "/message/SetDisplayNameReply");
+
+LLHTTPRegistration<LLDisplayNameUpdate>
+    gHTTPRegistrationMessageDisplayNameUpdate(
+                "/message/DisplayNameUpdate");
diff --git a/linden/indra/newview/llviewerdisplayname.h b/linden/indra/newview/llviewerdisplayname.h
new file mode 100644
index 0000000..16d59ae
--- /dev/null
+++ b/linden/indra/newview/llviewerdisplayname.h
@@ -0,0 +1,53 @@
+/** 
+ * @file llviewerdisplayname.h
+ * @brief Wrapper for display name functionality
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LLVIEWERDISPLAYNAME_H
+#define LLVIEWERDISPLAYNAME_H
+
+#include <boost/signals2.hpp>
+
+class LLSD;
+class LLUUID;
+
+namespace LLViewerDisplayName
+{
+        typedef boost::signals2::signal<
+                void (bool success, const std::string& reason, const LLSD& content)>
+                        set_name_signal_t;
+        typedef set_name_signal_t::slot_type set_name_slot_t;
+        
+        typedef boost::signals2::signal<void (void)> name_changed_signal_t;
+        typedef name_changed_signal_t::slot_type name_changed_slot_t;
+
+        // Sends an update to the server to change a display name
+        // and call back when done.  May not succeed due to service
+        // unavailable or name not available.
+        void set(const std::string& display_name, const set_name_slot_t& slot); 
+        
+        void addNameChangedCallback(const name_changed_signal_t::slot_type& cb);
+}
+
+#endif // LLVIEWERDISPLAYNAME_H
diff --git a/linden/indra/newview/llviewermedia.cpp b/linden/indra/newview/llviewermedia.cpp
index 5c01b25..f0faedf 100644
--- a/linden/indra/newview/llviewermedia.cpp
+++ b/linden/indra/newview/llviewermedia.cpp
@@ -402,7 +402,7 @@ bool LLViewerMediaImpl::initializeMedia(const std::string& mime_type)
         {
                 if(! initializePlugin(mime_type))
                 {
-                        LL_WARNS("Plugin") << "plugin intialization failed for mime type: " << mime_type << LL_ENDL;
+                        LL_WARNS("PluginViewerMedia") << "plugin intialization failed for mime type: " << mime_type << LL_ENDL;
                         LLSD args;
                         args["MIME_TYPE"] = mime_type;
                         LLNotifications::instance().add("NoPlugin", args);
@@ -520,7 +520,7 @@ LLPluginClassMedia* LLViewerMediaImpl::newSourceFromMediaType(std::string media_
                 }
         }
 
-        LL_WARNS("Plugin") << "plugin intialization failed for mime type: " << media_type << LL_ENDL;
+        LL_WARNS("PluginViewerMedia") << "plugin intialization failed for mime type: " << media_type << LL_ENDL;
         LLSD args;
         args["MIME_TYPE"] = media_type;
         LLNotifications::instance().add("NoPlugin", args);
diff --git a/linden/indra/newview/llviewermedia_streamingaudio.cpp b/linden/indra/newview/llviewermedia_streamingaudio.cpp
index 575dbc8..6a4dd0f 100644
--- a/linden/indra/newview/llviewermedia_streamingaudio.cpp
+++ b/linden/indra/newview/llviewermedia_streamingaudio.cpp
@@ -69,8 +69,13 @@ void LLStreamingAudio_MediaPlugins::start(const std::string& url)
                 llinfos << "mMediaPlugin is now " << mMediaPlugin << llendl;
         }
 
+        mVersion = mMediaPlugin ? mMediaPlugin->getPluginVersion() : std::string();
+
         if(!mMediaPlugin)
+        {
+                llinfos << "mMediaPlugin failed to initialize!" << llendl;
                 return;
+        }
         
         if (!url.empty()) {
                 llinfos << "Starting internet stream: " << url << llendl;
@@ -156,6 +161,11 @@ std::string LLStreamingAudio_MediaPlugins::getURL()
         return mURL;
 }
 
+std::string LLStreamingAudio_MediaPlugins::getVersion()
+{
+        return mVersion;
+}
+
 void LLStreamingAudio_MediaPlugins::handleMediaEvent(LLPluginClassMedia* self, EMediaEvent event)
 {
         if (event == MEDIA_EVENT_NAME_CHANGED)
diff --git a/linden/indra/newview/llviewermedia_streamingaudio.h b/linden/indra/newview/llviewermedia_streamingaudio.h
index 816e213..5802a31 100644
--- a/linden/indra/newview/llviewermedia_streamingaudio.h
+++ b/linden/indra/newview/llviewermedia_streamingaudio.h
@@ -56,6 +56,7 @@ class LLStreamingAudio_MediaPlugins :
         /*virtual*/ void setGain(F32 vol);
         /*virtual*/ F32 getGain();
         /*virtual*/ std::string getURL();
+        /*virtual*/ std::string getVersion();
 
         // inherited from LLPluginClassMediaOwner
         /*virtual*/ void handleMediaEvent(LLPluginClassMedia* self, EMediaEvent event);
@@ -66,6 +67,7 @@ private:
         LLPluginClassMedia *mMediaPlugin;
         std::string mURL;
         F32 mGain;
+        std::string mVersion;
 };
 
 
diff --git a/linden/indra/newview/llviewermenu.cpp b/linden/indra/newview/llviewermenu.cpp
index 7f00382..777a871 100644
--- a/linden/indra/newview/llviewermenu.cpp
+++ b/linden/indra/newview/llviewermenu.cpp
@@ -41,6 +41,7 @@
 
 // linden library includes
 #include "llaudioengine.h"
+#include "llavatarnamecache.h"
 #include "indra_constants.h"
 #include "llassetstorage.h"
 #include "llchat.h"
@@ -102,6 +103,7 @@
 #include "llfloatercustomize.h"
 #include "llfloaterdaycycle.h"
 #include "llfloaterdirectory.h"
+#include "llfloaterdisplayname.h"
 #include "llfloatereditui.h"
 #include "llfloaterchatterbox.h"
 #include "llfloaterfriends.h"
@@ -3434,6 +3436,16 @@ class LLEditEnableCustomizeAvatar : public view_listener_t
         }
 };
 
+class LLEditEnableDisplayName : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = (LLAvatarNameCache::useDisplayNames() != 0);
+                gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value);
+                return true;
+        }
+};
+
 // only works on pie menu
 bool handle_sit_or_stand()
 {
@@ -5959,6 +5971,10 @@ class LLShowFloater : public view_listener_t
                 {
                         LLToolBar::toggle(NULL);
                 }
+                else if (floater_name == "displayname")
+                {
+                        LLFloaterDisplayName::show();
+                }
                 else if (floater_name == "chat history")
                 {
                         LLFloaterChat::toggleInstance(LLSD());
@@ -10666,6 +10682,20 @@ class LLAdvancedDumpAvatarLocalTextures : public view_listener_t
         }
 };
 
+///////////////////////////////////
+// Reload Avatar Cloud Particles //
+///////////////////////////////////
+
+
+class LLAdvancedReloadAvatarCloudParticle : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLVOAvatar::initCloud();
+                return true;
+        }
+};
+
 ///////////
 // Crash //
 ///////////
@@ -11118,6 +11148,7 @@ void initialize_menus()
         addMenu(new LLEditEnableDuplicate(), "Edit.EnableDuplicate");
         addMenu(new LLEditEnableTakeOff(), "Edit.EnableTakeOff");
         addMenu(new LLEditEnableCustomizeAvatar(), "Edit.EnableCustomizeAvatar");
+        addMenu(new LLEditEnableDisplayName(), "Edit.EnableDisplayName");
         addMenu(new LLAdvancedRebakeTextures(), "Advanced.RebakeTextures");
 
         // View menu
@@ -11453,6 +11484,7 @@ void initialize_menus()
         addMenu(new LLAdvancedDumpAttachments(), "Advanced.DumpAttachments");
         addMenu(new LLAdvancedDebugAvatarTextures(), "Advanced.DebugAvatarTextures");
         addMenu(new LLAdvancedDumpAvatarLocalTextures(), "Advanced.DumpAvatarLocalTextures");
+        addMenu(new LLAdvancedReloadAvatarCloudParticle(), "Advanced.ReloadAvatarCloudParticle");
 
         // Advanced > Crash
         addMenu(new LLAdvancedCrash(), "Advanced.Crash");
diff --git a/linden/indra/newview/llviewermessage.cpp b/linden/indra/newview/llviewermessage.cpp
index 5f333e9..9ebfd04 100755
--- a/linden/indra/newview/llviewermessage.cpp
+++ b/linden/indra/newview/llviewermessage.cpp
@@ -2998,6 +2998,33 @@ void process_chat_from_simulator(LLMessageSystem *msg, void **user_data)
 
         if (is_audible)
         {
+                if (chatter && chatter->isAvatar())
+                {
+#ifdef LL_RRINTERFACE_H //MK
+                        if (!gRRenabled || !gAgent.mRRInterface.mContainsShownames)
+                        {
+#endif //mk
+                                if (LLAvatarNameCache::useDisplayNames())
+                                {
+                                        LLAvatarName avatar_name;
+                                        if (LLAvatarNameCache::get(from_id, &avatar_name))
+                                        {
+                                                if (LLAvatarNameCache::useDisplayNames() == 1)
+                                                {
+                                                        from_name = avatar_name.mDisplayName;
+                                                }
+                                                else
+                                                {
+                                                        from_name = avatar_name.getNames();
+                                                }
+                                        }
+                                        chat.mFromName = from_name;
+                                }
+#ifdef LL_RRINTERFACE_H //MK
+                        }
+#endif //mk
+                }
+
                 BOOL visible_in_chat_bubble = FALSE;
                 std::string verb;
 
diff --git a/linden/indra/newview/llviewerobject.cpp b/linden/indra/newview/llviewerobject.cpp
index a2be26a..65c1d11 100644
--- a/linden/indra/newview/llviewerobject.cpp
+++ b/linden/indra/newview/llviewerobject.cpp
@@ -4206,7 +4206,7 @@ void LLViewerObject::setParticleSource(const LLPartSysData& particle_parameters,
                         LLViewerImage* image;
                         if (mPartSourcep->mPartSysData.mPartImageID == LLUUID::null)
                         {
-                                image = gImageList.getImageFromFile("pixiesmall.tga");
+                                image = gImageList.getImageFromFile("pixiesmall.j2c");
                         }
                         else
                         {
diff --git a/linden/indra/newview/llviewerparcelmgr.cpp b/linden/indra/newview/llviewerparcelmgr.cpp
index b589f2e..630da54 100644
--- a/linden/indra/newview/llviewerparcelmgr.cpp
+++ b/linden/indra/newview/llviewerparcelmgr.cpp
@@ -35,7 +35,7 @@
 #include "llviewerparcelmgr.h"
 
 // Library includes
-#include "llaudioengine.h"
+#include "kokuastreamingaudio.h"
 #include "indra_constants.h"
 #include "llcachename.h"
 #include "llgl.h"
@@ -1672,7 +1672,7 @@ void LLViewerParcelMgr::processParcelProperties(LLMessageSystem *msg, void **use
         else
         {
                 // look for music.
-                if (gAudiop)
+                if (gAudioStream)
                 {
                         if (parcel)
                         {
@@ -1685,12 +1685,12 @@ void LLViewerParcelMgr::processParcelProperties(LLMessageSystem *msg, void **use
                                 // On entering a new parcel, stop the last stream if the
                                 // new parcel has a different music url.  (Empty URL counts
                                 // as different.)
-                                const std::string& stream_url = gAudiop->getInternetStreamURL();
+                                const std::string& stream_url = gAudioStream->getInternetStreamURL();
 
                                 if (music_url.empty() || music_url != stream_url)
                                 {
                                         // URL is different from one currently playing.
-                                        gAudiop->stopInternetStream();
+                                        gAudioStream->stopInternetStream();
 
                                         // If there is a new music URL and it's valid, play it.
                                         if (music_url.size() > 12)
@@ -1700,19 +1700,19 @@ void LLViewerParcelMgr::processParcelProperties(LLMessageSystem *msg, void **use
                                                         optionally_start_music(music_url);
                                                 }
                                         }
-                                        else if (!gAudiop->getInternetStreamURL().empty())
+                                        else if (!gAudioStream->getInternetStreamURL().empty())
                                         {
                                                 llinfos << "Stopping parcel music" << llendl;
-                                                gAudiop->startInternetStream(LLStringUtil::null);
+                                                gAudioStream->startInternetStream(LLStringUtil::null);
                                         }
                                 }
                         }
                         else
                         {
                                 // Public land has no music
-                                gAudiop->stopInternetStream();
+                                gAudioStream->stopInternetStream();
                         }
-                }//if gAudiop
+                }//if gAudioStream
 
                 // now check for video
                 LLViewerParcelMedia::update( parcel );
@@ -1730,7 +1730,7 @@ void optionally_start_music(const std::string& music_url)
                 // changed as part of SL-4878
                 if ( gOverlayBar && gOverlayBar->musicPlaying())
                 {
-                        gAudiop->startInternetStream(music_url);
+                        gAudioStream->startInternetStream(music_url);
                 }
         }
 }
diff --git a/linden/indra/newview/llviewerprecompiledheaders.h b/linden/indra/newview/llviewerprecompiledheaders.h
index 9bc6574..a0b99bf 100644
--- a/linden/indra/newview/llviewerprecompiledheaders.h
+++ b/linden/indra/newview/llviewerprecompiledheaders.h
@@ -165,7 +165,7 @@
 #include "llinstantmessage.h"
 #include "llinvite.h"
 //#include "llloginflags.h"
-#include "llmail.h"
+//#include "llmail.h"
 #include "llmessagethrottle.h"
 #include "llnamevalue.h"
 #include "llpacketack.h"
diff --git a/linden/indra/newview/llviewerregion.cpp b/linden/indra/newview/llviewerregion.cpp
index d93c425..a8047b8 100644
--- a/linden/indra/newview/llviewerregion.cpp
+++ b/linden/indra/newview/llviewerregion.cpp
@@ -127,6 +127,8 @@ public:
                         }
                 }
                 
+                mRegion->setCapabilitiesReceived(true);
+
                 if (STATE_SEED_GRANTED_WAIT == LLStartUp::getStartupState())
                 {
                         LLStartUp::setStartupState( STATE_SEED_CAP_GRANTED );
@@ -172,7 +174,8 @@ LLViewerRegion::LLViewerRegion(const U64 &handle,
         mCacheEntriesCount(0),
         mCacheID(),
         mEventPoll(NULL),
-        mReleaseNotesRequested(FALSE)
+        mReleaseNotesRequested(FALSE),
+        mCapabilitiesReceived(false)
 {
         mWidth = region_width_meters;
         mOriginGlobal = from_region_handle(handle); 
@@ -1431,6 +1434,8 @@ void LLViewerRegion::setSeedCapability(const std::string& url)
         capabilityNames.append("FetchInventory");
         capabilityNames.append("FetchLib");
         capabilityNames.append("FetchLibDescendents");
+        capabilityNames.append("GetDisplayNames");
+        capabilityNames.append("SetDisplayName");
         capabilityNames.append("GetTexture");
         capabilityNames.append("GroupProposalBallot");
         capabilityNames.append("HomeLocation");
@@ -1509,6 +1514,16 @@ std::string LLViewerRegion::getCapability(const std::string& name) const
         return iter->second;
 }
 
+bool LLViewerRegion::capabilitiesReceived() const
+{
+        return mCapabilitiesReceived;
+}
+
+void LLViewerRegion::setCapabilitiesReceived(bool received)
+{
+        mCapabilitiesReceived = received;
+}
+
 void LLViewerRegion::logActiveCapabilities() const
 {
         int count = 0;
diff --git a/linden/indra/newview/llviewerregion.h b/linden/indra/newview/llviewerregion.h
index 8cc80e3..5ce8b2e 100644
--- a/linden/indra/newview/llviewerregion.h
+++ b/linden/indra/newview/llviewerregion.h
@@ -229,6 +229,11 @@ public:
         void setSeedCapability(const std::string& url);
         void setCapability(const std::string& name, const std::string& url);
         std::string getCapability(const std::string& name) const;
+
+        // has region received its final (not seed) capability list?
+        bool capabilitiesReceived() const;
+        void setCapabilitiesReceived(bool received);
+
         static bool isSpecialCapabilityName(const std::string &name);
         void logActiveCapabilities() const;
 
@@ -399,6 +404,7 @@ private:
 
 private:
         bool    mAlive;                                 // can become false if circuit disconnects
+        bool    mCapabilitiesReceived;
 
         //spatial partitions for objects in this region
         std::vector<LLSpatialPartition*> mObjectPartition;
diff --git a/linden/indra/newview/llvoavatar.cpp b/linden/indra/newview/llvoavatar.cpp
index de6b22d..e1fa61f 100644
--- a/linden/indra/newview/llvoavatar.cpp
+++ b/linden/indra/newview/llvoavatar.cpp
@@ -38,6 +38,7 @@
 #include <ctype.h>
 
 #include "llaudioengine.h"
+#include "llavatarnamecache.h"
 #include "noise.h"
 
 #include "llagent.h" //  Get state values from here
@@ -748,6 +749,7 @@ LLVOAvatar::LLVOAvatar(const LLUUID& id,
         mAppearanceAnimating(FALSE),
         mNameString(),
         mTitle(),
+        mCompleteName(),
         mNameAway(FALSE),
         mNameBusy(FALSE),
         mNameMute(FALSE),
@@ -1474,6 +1476,7 @@ void LLVOAvatar::initClass()
         {
                 loadClientTags();
         }
+        initCloud();
 }
 
 
@@ -1489,6 +1492,21 @@ void LLVOAvatar::cleanupClass()
         sXMLTree.cleanup();
 }
 
+LLPartSysData LLVOAvatar::sCloud;
+void LLVOAvatar::initCloud()
+{
+        // fancy particle cloud designed by Brent
+
+        std::string filename = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "cloud.xml");
+        LLSD cloud;
+        llifstream in_file(filename);
+        LLSDSerialize::fromXMLDocument(cloud, in_file);
+        sCloud.fromLLSD(cloud);
+        LLViewerImage* cloud_image = gImageList.getImageFromFile("cloud-particle.j2c");
+        sCloud.mPartImageID                 = cloud_image->getID();
+
+}
+
 const LLVector3 LLVOAvatar::getRenderPosition() const
 {
         if (mDrawable.isNull() || mDrawable->getGeneration() < 0)
@@ -2872,7 +2890,7 @@ void LLVOAvatar::idleUpdateAppearanceAnimation()
                                  param;
                                  param = getNextVisualParam())
                         {
-                                if (param->getGroup() == VISUAL_PARAM_GROUP_TWEAKABLE)
+                                if (param->isTweakable())
                                 {
                                         param->stopAnimating(mAppearanceAnimSetByUser);
                                 }
@@ -2904,7 +2922,7 @@ void LLVOAvatar::idleUpdateAppearanceAnimation()
                                  param;
                                  param = getNextVisualParam())
                         {
-                                if (param->getGroup() == VISUAL_PARAM_GROUP_TWEAKABLE)
+                                if (param->isTweakable())
                                 {
                                         // so boobs don't go spastic when a shape's changed, but still seems buggy
                                         //if(param->getID() != 507)
@@ -3070,34 +3088,7 @@ void LLVOAvatar::idleUpdateLoadingEffect()
                 }
                 else
                 {
-                        LLPartSysData particle_parameters;
-
-                        // fancy particle cloud designed by Brent
-                        particle_parameters.mPartData.mMaxAge            = 4.f;
-                        particle_parameters.mPartData.mStartScale.mV[VX] = 0.8f;
-                        particle_parameters.mPartData.mStartScale.mV[VX] = 0.8f;
-                        particle_parameters.mPartData.mStartScale.mV[VY] = 1.0f;
-                        particle_parameters.mPartData.mEndScale.mV[VX]   = 0.02f;
-                        particle_parameters.mPartData.mEndScale.mV[VY]   = 0.02f;
-                        particle_parameters.mPartData.mStartColor        = LLColor4(1, 1, 1, 0.5f);
-                        particle_parameters.mPartData.mEndColor          = LLColor4(1, 1, 1, 0.0f);
-                        particle_parameters.mPartData.mStartScale.mV[VX] = 0.8f;
-                        LLViewerImage* cloud = gImageList.getImageFromFile("cloud-particle.j2c");
-                        particle_parameters.mPartImageID                 = cloud->getID();
-                        particle_parameters.mMaxAge                      = 0.f;
-                        particle_parameters.mPattern                     = LLPartSysData::LL_PART_SRC_PATTERN_ANGLE_CONE;
-                        particle_parameters.mInnerAngle                  = 3.14159f;
-                        particle_parameters.mOuterAngle                  = 0.f;
-                        particle_parameters.mBurstRate                   = 0.02f;
-                        particle_parameters.mBurstRadius                 = 0.0f;
-                        particle_parameters.mBurstPartCount              = 1;
-                        particle_parameters.mBurstSpeedMin               = 0.1f;
-                        particle_parameters.mBurstSpeedMax               = 1.f;
-                        particle_parameters.mPartData.mFlags             = ( LLPartData::LL_PART_INTERP_COLOR_MASK | LLPartData::LL_PART_INTERP_SCALE_MASK |
-                                                                                                                                 LLPartData::LL_PART_EMISSIVE_MASK | // LLPartData::LL_PART_FOLLOW_SRC_MASK |
-                                                                                                                                 LLPartData::LL_PART_TARGET_POS_MASK );
-
-                        setParticleSource(particle_parameters, getID());
+                        setParticleSource(sCloud, getID());
                 }
         }
 }
@@ -3633,6 +3624,35 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
 
                 if (mNameText.notNull() && firstname && lastname)
                 {
+                        std::string complete_name = firstname->getString();
+                        if (sRenderGroupTitles)
+                        {
+                                complete_name += " ";
+                        }
+                        else
+                        {
+                                // If all group titles are turned off, stack first name
+                                // on a line above last name
+                                complete_name += "\n";
+                        }
+                        complete_name += lastname->getString();
+
+                        if (LLAvatarNameCache::useDisplayNames())
+                        {
+                                LLAvatarName avatar_name;
+                                if (LLAvatarNameCache::get(getID(), &avatar_name))
+                                {
+                                        if (LLAvatarNameCache::useDisplayNames() == 1)
+                                        {
+                                                complete_name = avatar_name.mDisplayName;
+                                        }
+                                        else
+                                        {
+                                                complete_name = avatar_name.getNames(true);
+                                        }
+                                }
+                        }
+
                         BOOL is_away = mSignaledAnimations.find(ANIM_AGENT_AWAY)  != mSignaledAnimations.end();
                         BOOL is_busy = mSignaledAnimations.find(ANIM_AGENT_BUSY) != mSignaledAnimations.end();
                         BOOL is_appearance = mSignaledAnimations.find(ANIM_AGENT_CUSTOMIZE) != mSignaledAnimations.end();
@@ -3647,7 +3667,7 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
                         }
 
                         if (mNameString.empty() ||
-                                new_name ||
+                                new_name || complete_name != mCompleteName ||
                                 (!title && !mTitle.empty()) ||
                                 (title && mTitle != title->getString()) ||
                                 (is_away != mNameAway || is_busy != mNameBusy || is_muted != mNameMute)
@@ -3663,20 +3683,19 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
                                                 line += title->getString();
                                                 //LLStringFn::replace_ascii_controlchars(line,LL_UNKNOWN_CHAR); IMP-136 -- McCabe
                                                 line += "\n";
-                                                line += firstname->getString();
+                                                line += complete_name;
                                         }
                                         else
                                         {
-                                                line += firstname->getString();
+                                                line += complete_name;
                                         }
 
-                                        line += " ";
-                                        line += lastname->getString();
+
 // [RLVa:KB] - Version: 1.23.4 | Checked: 2009-07-08 (RLVa-1.0.0e) | Added: RLVa-0.2.0b
                                 }
                                 else
                                 {
-                                        line = RlvStrings::getAnonym(line.assign(firstname->getString()).append(" ").append(lastname->getString()));
+                                        line = RlvStrings::getAnonym(complete_name);
                                 }
 // [/RLVa:KB]
 
@@ -3686,7 +3705,7 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
                                 bool show_client = client.length() != 0 && (*sShowClientNameTag);
                                 if (is_away || is_muted || is_busy || show_client)
                                 {
-                                        line += " (";
+                                        line += "\n(";
                                         if (is_away)
                                         {
                                                 line += "Away";
@@ -3731,6 +3750,7 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
                                 mNameMute = is_muted;
                                 mNameAppearance = is_appearance;
                                 mTitle = title ? title->getString() : "";
+                                mCompleteName = complete_name;
                                 //LLStringFn::replace_ascii_controlchars(mTitle,LL_UNKNOWN_CHAR); IMP-136 -- McCabe
                                 mNameString = utf8str_to_wstring(line);
                                 new_name = TRUE;
@@ -3847,6 +3867,41 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
         }
 }
 
+void LLVOAvatar::clearNameTag()
+{
+        mNameString.clear();
+        if (mNameText)
+        {
+                mNameText->setLabel("");
+                mNameText->setString(mNameString);
+        }
+}
+
+//static
+void LLVOAvatar::invalidateNameTag(const LLUUID& agent_id)
+{
+        LLViewerObject* obj = gObjectList.findObject(agent_id);
+        if (!obj) return;
+
+        LLVOAvatar* avatar = dynamic_cast<LLVOAvatar*>(obj);
+        if (!avatar) return;
+
+        avatar->clearNameTag();
+}
+
+//static
+void LLVOAvatar::invalidateNameTags()
+{
+        std::vector<LLCharacter*>::iterator it;
+        for (it = LLCharacter::sInstances.begin(); it != LLCharacter::sInstances.end(); ++it)
+        {
+                LLVOAvatar* avatar = dynamic_cast<LLVOAvatar*>(*it);
+                if (!avatar) continue;
+                if (avatar->isDead()) continue;
+
+                avatar->clearNameTag();
+        }
+}
 
 void LLVOAvatar::idleUpdateTractorBeam()
 {
@@ -4833,6 +4888,7 @@ U32 LLVOAvatar::renderSkinned(EAvatarRenderPass pass)
                                                                             && !LLDrawPoolAlpha::sShowDebugAlpha // Don't alpha mask if "Highlight Transparent" checked
                                                                                 && !LLDrawPoolAvatar::sSkipTransparent;
 
+
                 LLGLState test(GL_ALPHA_TEST, should_alpha_mask);
 
                 if (should_alpha_mask)
@@ -4948,7 +5004,6 @@ U32 LLVOAvatar::renderRigid()
                                                                     && !LLDrawPoolAlpha::sShowDebugAlpha // Don't alpha mask if "Highlight Transparent" checked
                                                                         && !LLDrawPoolAvatar::sSkipTransparent;
 
-
         LLGLState test(GL_ALPHA_TEST, should_alpha_mask);
 
         if (should_alpha_mask)
@@ -5931,6 +5986,7 @@ BOOL LLVOAvatar::loadAvatar()
         if (sAvatarXmlInfo->mLayerInfoList.empty())
         {
                 llwarns << "avatar file: missing <layer_set> node" << llendl;
+                return FALSE;
         }
         else
         {
@@ -5971,23 +6027,22 @@ BOOL LLVOAvatar::loadAvatar()
         }
 
         // avatar_lad.xml : <driver_parameters>
+        LLVOAvatarXmlInfo::driver_info_list_t::iterator iter;
+        for (iter = sAvatarXmlInfo->mDriverInfoList.begin();
+                 iter != sAvatarXmlInfo->mDriverInfoList.end(); iter++)
         {
-                LLVOAvatarXmlInfo::driver_info_list_t::iterator iter;
-                for (iter = sAvatarXmlInfo->mDriverInfoList.begin();
-                         iter != sAvatarXmlInfo->mDriverInfoList.end(); iter++)
+                LLDriverParamInfo *info = *iter;
+                LLDriverParam* driver_param = new LLDriverParam( this );
+                if (driver_param->setInfo(info))
                 {
-                        LLDriverParamInfo *info = *iter;
-                        LLDriverParam* driver_param = new LLDriverParam( this );
-                        if (driver_param->setInfo(info))
-                        {
-                                addVisualParam( driver_param );
-                        }
-                        else
-                        {
-                                delete driver_param;
-                                llwarns << "avatar file: driver_param->parseData() failed" << llendl;
-                                return FALSE;
-                        }
+                        addVisualParam( driver_param );
+                }
+                else
+                {
+                        delete driver_param;
+                        llwarns << "avatar file: driver_param->parseData() failed" << llendl;
+                        return FALSE;
+
                 }
         }
 
@@ -8160,6 +8215,14 @@ BOOL LLVOAvatar::teToColorParams( ETextureIndex te, const char* param_name[3] )
                 param_name[2] = "skirt_blue";
                 break;
 
+        case TEX_HEAD_TATTOO:
+        case TEX_LOWER_TATTOO:
+        case TEX_UPPER_TATTOO:
+                param_name[0] = "tattoo_red";
+                param_name[1] = "tattoo_green";
+                param_name[2] = "tattoo_blue";
+                break;  
+
         default:
                 llassert(0);
                 return FALSE;
@@ -8619,7 +8682,7 @@ void LLVOAvatar::processAvatarAppearance( LLMessageSystem* mesgsys )
                 {
                         for( S32 i = 0; i < num_blocks; i++ )
                         {
-                                while( param && (param->getGroup() != VISUAL_PARAM_GROUP_TWEAKABLE) )
+                                while( param && (!param->isTweakable()) )
                                 {
                                         param = getNextVisualParam();
                                 }
@@ -8627,7 +8690,7 @@ void LLVOAvatar::processAvatarAppearance( LLMessageSystem* mesgsys )
                                 if( !param )
                                 {
                                         llwarns << "Number of params in AvatarAppearance msg does not match number of params in avatar xml file." << llendl;
-                                        return;
+                                        break;
                                 }
 
                                 U8 value;
@@ -8668,14 +8731,10 @@ void LLVOAvatar::processAvatarAppearance( LLMessageSystem* mesgsys )
                         }
                 }
 
-                while( param && (param->getGroup() != VISUAL_PARAM_GROUP_TWEAKABLE) )
+                S32 expected_tweakable_count = getVisualParamCountInGroup(VISUAL_PARAM_GROUP_TWEAKABLE); // don't worry about VISUAL_PARAM_GROUP_TWEAKABLE_NO_TRANSMIT
+                if (num_blocks != expected_tweakable_count)
                 {
-                        param = getNextVisualParam();
-                }
-                if( param )
-                {
-                        llwarns << "Number of params in AvatarAppearance msg does not match number of params in avatar xml file." << llendl;
-                        return;
+                        llinfos << "Number of params in AvatarAppearance msg (" << num_blocks << ") does not match number of tweakable params in avatar xml file (" << expected_tweakable_count << "). Processing what we can. Object: " << getID() << llendl;
                 }
 
                 if (params_changed)
@@ -8946,8 +9005,7 @@ void LLVOAvatar::dumpArchetypeXML( void* )
                 for( LLVisualParam* param = avatar->getFirstVisualParam(); param; param = avatar->getNextVisualParam() )
                 {
                         LLViewerVisualParam* viewer_param = (LLViewerVisualParam*)param;
-                        if( (viewer_param->getWearableType() == type) &&
-                                (viewer_param->getGroup() == VISUAL_PARAM_GROUP_TWEAKABLE) )
+                        if (viewer_param->getWearableType() == type && viewer_param->isTweakable())
                         {
                                 apr_file_printf( file, "\t\t<param id=\"%d\" name=\"%s\" value=\"%.3f\"/>\n",
                                                  viewer_param->getID(), viewer_param->getName().c_str(), viewer_param->getWeight() );
diff --git a/linden/indra/newview/llvoavatar.h b/linden/indra/newview/llvoavatar.h
index 548818d..e585a6a 100644
--- a/linden/indra/newview/llvoavatar.h
+++ b/linden/indra/newview/llvoavatar.h
@@ -97,6 +97,7 @@ public:
         static void initClass(); // Initialize data that's only init'd once per class.
         static void cleanupClass();     // Cleanup data that's only init'd once per class.
         static BOOL parseSkeletonFile(const std::string& filename);
+        static void initCloud();
         virtual U32 processUpdateMessage(LLMessageSystem *mesgsys,
                                                                          void **user_data,
                                                                          U32 block_num,
@@ -111,6 +112,10 @@ public:
         void idleUpdateWindEffect();
         void idleUpdateBoobEffect();
         void idleUpdateNameTag(const LLVector3& root_pos_last);
+        void clearNameTag();
+        static void invalidateNameTag(const LLUUID& agent_id);
+        // force all name tags to rebuild, useful when display names turned on/off
+        static void invalidateNameTags();
         void idleUpdateRenderCost();
         void idleUpdateTractorBeam();
         void idleUpdateBelowWater();
@@ -582,6 +587,7 @@ public:
         static F32              sLODFactor; // user-settable LOD factor
         static BOOL             sJointDebug; // output total number of joints being touched for each avatar
         static BOOL     sDebugAvatarRotation;
+        static LLPartSysData sCloud;
 
         static S32 sNumVisibleAvatars; // Number of instances of this class
         
@@ -675,6 +681,7 @@ protected:
 
         LLWString mNameString;
         std::string  mTitle;
+        std::string  mCompleteName;
         BOOL      mNameAway;
         BOOL      mNameBusy;
         BOOL      mNameMute;
diff --git a/linden/indra/newview/llvoiceclient.cpp b/linden/indra/newview/llvoiceclient.cpp
index d67b9e3..7b1ed95 100644
--- a/linden/indra/newview/llvoiceclient.cpp
+++ b/linden/indra/newview/llvoiceclient.cpp
@@ -1795,7 +1795,7 @@ void LLVoiceClient::stateMachine()
 
                                 if(!mSocket)
                                 {
-                                        mSocket = LLSocket::create(gAPRPoolp, LLSocket::STREAM_TCP);    
+                                        mSocket = LLSocket::create(LLSocket::STREAM_TCP);
                                 }
                                 
                                 mConnected = mSocket->blockingConnect(mDaemonHost);
diff --git a/linden/indra/newview/llwatchdog.cpp b/linden/indra/newview/llwatchdog.cpp
index 330bc8a..9af050c 100644
--- a/linden/indra/newview/llwatchdog.cpp
+++ b/linden/indra/newview/llwatchdog.cpp
@@ -184,8 +184,8 @@ void LLWatchdog::init(killer_event_callback func)
         mKillerCallback = func;
         if(!mSuspectsAccessMutex && !mTimer)
         {
-                mSuspectsAccessMutex = new LLMutex(NULL);
-                mTimer = new LLWatchdogTimerThread();
+                mSuspectsAccessMutex = new LLMutex;
+                mTimer = new LLWatchdogTimerThread;
                 mTimer->setSleepTime(WATCHDOG_SLEEP_TIME_USEC / 1000);
                 mLastClockCount = LLTimer::getTotalTime();
 
diff --git a/linden/indra/newview/llwearable.cpp b/linden/indra/newview/llwearable.cpp
index b74ef02..f8123bb 100644
--- a/linden/indra/newview/llwearable.cpp
+++ b/linden/indra/newview/llwearable.cpp
@@ -535,7 +535,7 @@ BOOL LLWearable::isOldVersion()
                 param;
                 param = (LLViewerVisualParam*) avatar->getNextVisualParam() )
         {
-                if( (param->getWearableType() == mType) && (param->getGroup() == VISUAL_PARAM_GROUP_TWEAKABLE ) )
+                if (param->getWearableType() == mType && param->isTweakable())
                 {
                         param_count++;
                         if( !is_in_map(mVisualParamMap, param->getID() ) )
@@ -591,7 +591,7 @@ BOOL LLWearable::isDirty()
                 param;
                 param = (LLViewerVisualParam*) avatar->getNextVisualParam() )
         {
-                if( (param->getWearableType() == mType) && (param->getGroup() == VISUAL_PARAM_GROUP_TWEAKABLE ) )
+                if (param->getWearableType() == mType && param->isTweakable())
                 {
                         F32 weight = get_if_there(mVisualParamMap, param->getID(), param->getDefaultWeight());
                         weight = llclamp( weight, param->getMinWeight(), param->getMaxWeight() );
@@ -690,7 +690,7 @@ void LLWearable::setParamsToDefaults()
         mVisualParamMap.clear();
         for( LLVisualParam* param = avatar->getFirstVisualParam(); param; param = avatar->getNextVisualParam() )
         {
-                if( (((LLViewerVisualParam*)param)->getWearableType() == mType ) && (param->getGroup() == VISUAL_PARAM_GROUP_TWEAKABLE ) )
+                if (((LLViewerVisualParam*)param)->getWearableType() == mType && param->isTweakable())
                 {
                         mVisualParamMap[param->getID()] = param->getDefaultWeight();
                 }
@@ -724,7 +724,7 @@ void LLWearable::writeToAvatar( BOOL set_by_user )
         // Pull params
         for( LLVisualParam* param = avatar->getFirstVisualParam(); param; param = avatar->getNextVisualParam() )
         {
-                if( (((LLViewerVisualParam*)param)->getWearableType() == mType) && (param->getGroup() == VISUAL_PARAM_GROUP_TWEAKABLE ) )
+                if (((LLViewerVisualParam*)param)->getWearableType() == mType && param->isTweakable())
                 {
                         S32 param_id = param->getID();
                         F32 weight = get_if_there(mVisualParamMap, param_id, param->getDefaultWeight());
@@ -825,7 +825,7 @@ void LLWearable::removeFromAvatar( EWearableType type, BOOL set_by_user )
         // Pull params
         for( LLVisualParam* param = avatar->getFirstVisualParam(); param; param = avatar->getNextVisualParam() )
         {
-                if( (((LLViewerVisualParam*)param)->getWearableType() == type) && (param->getGroup() == VISUAL_PARAM_GROUP_TWEAKABLE ) )
+                if (((LLViewerVisualParam*)param)->getWearableType() == type && param->isTweakable())
                 {
                         S32 param_id = param->getID();
                         avatar->setVisualParamWeight( param_id, param->getDefaultWeight(), set_by_user );
@@ -873,7 +873,7 @@ void LLWearable::readFromAvatar()
         mVisualParamMap.clear();
         for( LLVisualParam* param = avatar->getFirstVisualParam(); param; param = avatar->getNextVisualParam() )
         {
-                if( (((LLViewerVisualParam*)param)->getWearableType() == mType) && (param->getGroup() == VISUAL_PARAM_GROUP_TWEAKABLE ) )
+                if (((LLViewerVisualParam*)param)->getWearableType() == mType && param->isTweakable())
                 {
                         
                         //pretty sure is right
@@ -938,7 +938,7 @@ void LLWearable::copyDataFrom( LLWearable* src )
                 param;
                 param = (LLViewerVisualParam*) avatar->getNextVisualParam() )
         {
-                if( (param->getWearableType() == mType) && (param->getGroup() == VISUAL_PARAM_GROUP_TWEAKABLE ) )
+                if (param->getWearableType() == mType && param->isTweakable())
                 {
                         S32 id = param->getID();
                         F32 weight = get_if_there(src->mVisualParamMap, id, param->getDefaultWeight() );
diff --git a/linden/indra/newview/skins/default/xui/de/notifications.xml b/linden/indra/newview/skins/default/xui/de/notifications.xml
index b2975df..3e08d33 100644
--- a/linden/indra/newview/skins/default/xui/de/notifications.xml
+++ b/linden/indra/newview/skins/default/xui/de/notifications.xml
@@ -1442,21 +1442,6 @@ Die Option zum Austritt aus einer Gruppe finden Sie unter „Bearbeiten“ &gt;
                         <button name="Cancel" text="Abbrechen"/>
                 </form>
         </notification>
-        <notification label="Linden-Grundstück ändern" name="ChangeLindenEstate">
-                Sie sind im Begriff, ein Grundstück in Linden-Besitz (Mainland, Teen-Raster, Orientierung usw.) zu verändern.
-
-Dies ist ÄUSSERST GEFÄHRLICH, da es grundlegende Auswirkungen auf das Benutzererlebnis hat.  Auf dem Mainland werden tausende Regionen geändert, was den Spaceserver stark belastet.
-
-Fortfahren?
-                <usetemplate name="okcancelbuttons" notext="Abbrechen" yestext="OK"/>
-        </notification>
-        <notification label="Zugang zu Linden-Grundstück ändern" name="ChangeLindenAccess">
-                Sie sind im Begriff, die Zugangsliste für ein Grundstück in Linden-Besitz (Mainland, Teen-Raster, Orientierung usw.) zu verändern.
-
-Dies ist GEFÄHRLICH und sollte nur erfolgen, um Objekte/L$ per Hack in und aus dem Raster zu entfernen.
-Tausende Regionen werden verändert und der Spaceserver wird dadurch stark belastet.
-                <usetemplate name="okcancelbuttons" notext="Abbrechen" yestext="OK"/>
-        </notification>
         <notification label="Grundstück wählen" name="EstateAllowedAgentAdd">
                 Nur für dieses Grundstück oder für alle [ALL_ESTATES] zur Erlaubnisliste hinzufügen?
                 <usetemplate canceltext="Abbrechen" name="yesnocancelbuttons" notext="Alle Grundstücke" yestext="Dieses Grundstück"/>
diff --git a/linden/indra/newview/skins/default/xui/en-us/floater_customize.xml b/linden/indra/newview/skins/default/xui/en-us/floater_customize.xml
index a0dd938..d5b61a7 100644
--- a/linden/indra/newview/skins/default/xui/en-us/floater_customize.xml
+++ b/linden/indra/newview/skins/default/xui/en-us/floater_customize.xml
@@ -1172,11 +1172,15 @@ scratch and wear it.
             <texture_picker name="Lower Tattoo" label="Lower Tattoo" tool_tip="Click to choose a picture"
              can_apply_immediately="true" default_image_name="Default" allow_no_texture="true"
              follows="left|top" width="70" height="80" left="14" bottom="-325"/>
+                        <color_swatch border_color="0.45098 0.517647 0.607843 1" bottom="-415"
+                             can_apply_immediately="true" color="1 1 1 1" follows="left|top" height="80"
+                             label="Color/Tint" left="14" mouse_opaque="true" name="Color/Tint"
+                             tool_tip="Click to open Color Picker" width="70" />
                         <button name="Create New" label="Create New Tattoo" label_selected="Create New Tattoo"
                  follows="left|top" halign="center" width="170" height="24" left="8" bottom="-128"
                              mouse_opaque="true" scale_image="true"/>
             <button name="Take Off" label="Take Off" label_selected="Take Off"
-             follows="left|top" width="82" height="20" left="8" bottom="-365"/>
+             follows="left|top" width="82" height="20" left="8" bottom="-440"/>
             <button name="Save" label="Save" label_selected="Save"
              follows="right|bottom" width="82" height="20" left="123" bottom="-478"/>
             <button name="Save As" label="Save As..." label_selected="Save As..."
diff --git a/linden/indra/newview/skins/default/xui/en-us/floater_display_name.xml b/linden/indra/newview/skins/default/xui/en-us/floater_display_name.xml
new file mode 100644
index 0000000..5875efb
--- /dev/null
+++ b/linden/indra/newview/skins/default/xui/en-us/floater_display_name.xml
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<floater name="Display Name" title="CHANGE DISPLAY NAME"
+ can_minimize="true" can_close="true" can_resize="false"
+ enabled="true" mouse_opaque="true" 
+ height="235" width="440">
+        <text name="info_text1" font="SansSerif" wrap="true"
+         height="18" width="380" left="42" bottom_delta="-48" follows="left|top">
+                The name you give to your avatar is called your Display Name.
+        </text>
+        <text name="info_text2" font="SansSerif" wrap="true"
+         height="18" width="300" left="120" bottom_delta="-18" follows="left|top">
+                You can change it once a week.
+        </text>
+        <text name="now_ok_text" font="SansSerif"
+         height="18" width="320" left="105" bottom_delta="-25" follows="left|top">
+                You can change it now if you so wish.
+        </text>
+        <text name="lockout_text" font="SansSerif" visible="false"
+         height="18" width="380" left="20" bottom_delta="0" follows="left|top">
+                You cannot change it before: [TIME].
+        </text>
+        <text name="set_name_label" font="SansSerif"
+         height="20" width="380" left="20" bottom_delta="-25" follows="left|top">
+                New Display Name:
+        </text>
+        <line_editor name="display_name_editor" max_length="31"
+         height="20" width="360" left="40" bottom_delta="-20" follows="left|top" />
+        <text name="name_confirm_label" font="SansSerif"
+         height="20" width="380" left="20" bottom_delta="-32" follows="left|top">
+                Type your new name again to confirm:
+        </text>
+        <line_editor name="display_name_confirm" max_length="31"
+         height="20" width="360" left="40" bottom_delta="-20" follows="left|top" />
+    <button name="save_btn" label="Save" font="SansSerif"
+         tool_tip="Save your new Display Name"
+     height="20" width="120" left="30" bottom_delta="-32"/>
+    <button name="reset_btn" label="Reset" font="SansSerif"
+         tool_tip="Make Display Name the same as Username"
+     height="20" width="120" left_delta="130" bottom_delta="0"/>
+    <button name="cancel_btn" label="Cancel" font="SansSerif"
+     height="20" width="120" left_delta="130" bottom_delta="0"/>
+</floater>
diff --git a/linden/indra/newview/skins/default/xui/en-us/floater_new_im.xml b/linden/indra/newview/skins/default/xui/en-us/floater_new_im.xml
index c93b890..5d766be 100644
--- a/linden/indra/newview/skins/default/xui/en-us/floater_new_im.xml
+++ b/linden/indra/newview/skins/default/xui/en-us/floater_new_im.xml
@@ -8,7 +8,7 @@
              column_padding="5" draw_border="true" draw_heading="false"
              draw_stripes="true" enabled="true" follows="left|top|right|bottom"
              height="290" left="6" mouse_opaque="true" multi_select="false"
-             name="user_list" width="421" />
+             name="user_list" use_display_names="true" width="421" />
         <button bottom="-271" enabled="true" follows="right|bottom" font="SansSerif"
              halign="center" height="20" label="Start" label_selected="Start" left="435"
              mouse_opaque="true" name="start_btn" scale_image="true" sound_flags="0"
@@ -17,9 +17,6 @@
              halign="center" height="20" label="Close" label_selected="Close" left="435"
              mouse_opaque="true" name="close_btn" scale_image="true" sound_flags="0"
              width="60" />
-        <string name="name_format">
-                [FIRST] [LAST]
-        </string>
         <string name="online_descriptor">
                 (online)
         </string>
diff --git a/linden/indra/newview/skins/default/xui/en-us/floater_new_outfit_dialog.xml b/linden/indra/newview/skins/default/xui/en-us/floater_new_outfit_dialog.xml
index 81dd05a..69e62f8 100644
--- a/linden/indra/newview/skins/default/xui/en-us/floater_new_outfit_dialog.xml
+++ b/linden/indra/newview/skins/default/xui/en-us/floater_new_outfit_dialog.xml
@@ -21,7 +21,7 @@
         <check_box bottom="-276" enabled="true" follows="left|top" font="SansSerifSmall"
              height="16" initial_value="false" label="Eyes" left="13"
              mouse_opaque="true" name="checkbox_Eyes" radio_style="false" width="100" />
-        <check_box bottom="-456" enabled="true" follows="left|top" font="SansSerifSmall"
+        <check_box bottom="-434" enabled="true" follows="left|top" font="SansSerifSmall"
              height="16" initial_value="false" label="Rename Clothing To Folder Name"
              left="13" mouse_opaque="true" name="rename" radio_style="false" width="210" />
         <check_box bottom="-216" enabled="true" follows="left|top" font="SansSerifSmall"
@@ -256,7 +256,7 @@ now wearing into it.
                 Attachments:
         </text>
         <text type="string" length="1" bg_visible="false" border_drop_shadow_visible="false" border_visible="false"
-             bottom="-436" drop_shadow_visible="true" enabled="true" follows="left|top"
+             bottom="-414" drop_shadow_visible="true" enabled="true" follows="left|top"
              font="SansSerifSmall" h_pad="0" halign="left" height="14" left="13"
              mouse_opaque="true" name="Options:" v_pad="0" width="100">
                 Options:
diff --git a/linden/indra/newview/skins/default/xui/en-us/floater_world_map.xml b/linden/indra/newview/skins/default/xui/en-us/floater_world_map.xml
index daf217e..314ad20 100644
--- a/linden/indra/newview/skins/default/xui/en-us/floater_world_map.xml
+++ b/linden/indra/newview/skins/default/xui/en-us/floater_world_map.xml
@@ -154,7 +154,7 @@
              mouse_opaque="true" name="spin y"

              tool_tip="Y coordinate of location to show on map" width="48" />

         <spinner bottom_delta="0" decimal_digits="0" follows="bottom|right" height="16"

-             increment="1" initial_val="0" left_delta="50" max_val="4096" min_val="0"

+             increment="1" initial_val="0" left_delta="50" max_val="16383" min_val="0"

              mouse_opaque="true" name="spin z"

              tool_tip="Z coordinate of location to show on map" width="48" />

         <button bottom="-625" follows="right|bottom" font="SansSerif" halign="center"

diff --git a/linden/indra/newview/skins/default/xui/en-us/menu_viewer.xml b/linden/indra/newview/skins/default/xui/en-us/menu_viewer.xml
index 31e730a..c2424d7 100644
--- a/linden/indra/newview/skins/default/xui/en-us/menu_viewer.xml
+++ b/linden/indra/newview/skins/default/xui/en-us/menu_viewer.xml
@@ -259,6 +259,11 @@
                 userdata="appearance" />
       <on_enable function="Edit.EnableCustomizeAvatar" />
     </menu_item_call>
+    <menu_item_call bottom="-362" enabled="true" height="19" label="Display Name..." left="0"
+                    mouse_opaque="true" name="Display Name..." width="153">
+        <on_click function="ShowFloater" userdata="displayname" />
+        <on_enable function="Edit.EnableDisplayName" />
+    </menu_item_call>
     <menu_item_separator />
     <menu_item_check name="Friends" label="Friends"
                      shortcut="control|shift|F">
@@ -267,7 +272,8 @@
       <on_check function="FloaterVisible"
                 userdata="friends" />
     </menu_item_check>
-    <menu_item_call name="Groups" label="Groups">
+    <menu_item_call name="Groups" label="Groups"
+                    shortcut="control|shift|G">
       <on_click function="ShowAgentGroups"
                 userdata="agent" />
     </menu_item_call>
@@ -1965,6 +1971,13 @@
         <on_click function="Advanced.DumpAttachments"
                   userdata="" />
       </menu_item_call>
+      <menu_item_call
+              label="Reload Avatar Cloud Particle"
+              name="Reload Avatar Cloud Particle">
+                <on_click
+                 function="Advanced.ReloadAvatarCloudParticle"
+                 userdata="" />
+      </menu_item_call>
     </menu>
 
     <!-- CRASH -->
diff --git a/linden/indra/newview/skins/default/xui/en-us/mime_types_windows.xml b/linden/indra/newview/skins/default/xui/en-us/mime_types_windows.xml
index 61067da..5ee4ed0 100644
--- a/linden/indra/newview/skins/default/xui/en-us/mime_types_windows.xml
+++ b/linden/indra/newview/skins/default/xui/en-us/mime_types_windows.xml
@@ -142,7 +142,7 @@
                         audio
                 </widgettype>
                 <impl>
-                        media_plugin_quicktime
+                        media_plugin_gstreamer010
                 </impl>
         </mimetype>
         <mimetype name="video/*">
@@ -197,8 +197,8 @@
                         audio
                 </widgettype>
                 <impl>
-                        media_plugin_quicktime
-                </impl>
+      media_plugin_gstreamer010
+    </impl>
         </mimetype>
         <mimetype name="application/pdf">
                 <label name="application/pdf_label">
@@ -274,8 +274,8 @@
                         audio
                 </widgettype>
                 <impl>
-                        media_plugin_quicktime
-                </impl>
+      media_plugin_gstreamer010
+    </impl>
         </mimetype>
         <mimetype name="audio/mpeg">
                 <label name="audio/mpeg_label">
@@ -285,8 +285,8 @@
                         audio
                 </widgettype>
                 <impl>
-                        media_plugin_quicktime
-                </impl>
+      media_plugin_gstreamer010
+    </impl>
         </mimetype>
         <mimetype name="audio/x-aiff">
                 <label name="audio/x-aiff_label">
@@ -296,8 +296,8 @@
                         audio
                 </widgettype>
                 <impl>
-                        media_plugin_quicktime
-                </impl>
+      media_plugin_gstreamer010
+    </impl>
         </mimetype>
         <mimetype name="audio/x-wav">
                 <label name="audio/x-wav_label">
@@ -307,8 +307,8 @@
                         audio
                 </widgettype>
                 <impl>
-                        media_plugin_quicktime
-                </impl>
+      media_plugin_gstreamer010
+    </impl>
         </mimetype>
         <mimetype menu="1" name="image/bmp">
                 <label name="image/bmp_label">
diff --git a/linden/indra/newview/skins/default/xui/en-us/notifications.xml b/linden/indra/newview/skins/default/xui/en-us/notifications.xml
index be29df8..358dbbf 100644
--- a/linden/indra/newview/skins/default/xui/en-us/notifications.xml
+++ b/linden/indra/newview/skins/default/xui/en-us/notifications.xml
@@ -3194,30 +3194,11 @@ Type a short announcement which will be sent to everyone currently in your estat
 
 <notification
  icon="alert.tga"
- label="Change Linden Estate"
- name="ChangeLindenEstate"
+ label="Pfft some old linden crap"
+ name="PfftLindenCrap"
  type="alert">
-You are about to change a Linden owned estate (mainland, teen grid, orientation, etc.).
-
-This is EXTREMELY DANGEROUS because it can fundamentally affect the user experience.  On the mainland, it will change thousands of regions and make the spaceserver hiccup.
-
-Proceed?
-  <usetemplate
-   name="okcancelbuttons"
-   notext="Cancel"
-   yestext="OK"/>
-</notification>
-
-<notification
- icon="alert.tga"
- label="Change Linden Estate Access"
- name="ChangeLindenAccess"
- type="alert">
-You are about to change the access list for a Linden owned estate (mainland, teen grid, orientation, etc.).
-
-This is DANGEROUS and should only be done to invoke the hack allowing objects/[CURRENCY] to be transfered in/out of a grid.
-
-It will change thousands of regions and make the spaceserver hiccup.
+This used to be some Linden inspired crap, but should never be seen now.
+Still unravelling the code before I make this go away.
   <usetemplate
    name="okcancelbuttons"
    notext="Cancel"
@@ -5237,6 +5218,88 @@ The string [STRING_NAME] is missing from strings.xml
 </notification>
 
 <notification
+   icon="alertmodal.tga"
+   name="SetDisplayNameSuccess"
+   type="alert">
+Hi [DISPLAY_NAME]!
+
+Just like in real life, it takes a while for everyone to learn about a new name.  Please allow several days for your name to update in objects, scripts, search, etc.
+  </notification>
+
+  <notification
+ icon="alertmodal.tga"
+ name="SetDisplayNameBlocked"
+ type="alert">
+Sorry, you cannot change your display name. If you feel this is in error, please contact support.
+  </notification>
+
+  <notification
+   icon="alertmodal.tga"
+   name="SetDisplayNameFailedLength"
+   type="alertmodal">
+Sorry, that name is too long.  Display names can have a maximum of [LENGTH] characters.
+
+Please try a shorter name.
+  </notification>
+
+  <notification
+   icon="alertmodal.tga"
+   name="SetDisplayNameFailedGeneric"
+   type="alertmodal">
+    Sorry, we could not set your display name.  Please try again later.
+  </notification>
+
+  <notification
+   icon="alertmodal.tga"
+   name="SetDisplayNameMismatch"
+   type="alertmodal">
+    The display names you entered do not match. Please re-enter.
+  </notification>
+
+  <!-- *NOTE: This should never happen -->
+  <notification
+   icon="alertmodal.tga"
+   name="AgentDisplayNameUpdateThresholdExceeded"
+   type="alertmodal">
+Sorry, you have to wait longer before you can change your display name.
+
+See http://wiki.secondlife.com/wiki/Setting_your_display_name
+
+Please try again later.
+  </notification>
+
+  <notification
+   icon="alertmodal.tga"
+   name="AgentDisplayNameSetBlocked"
+   type="alertmodal">
+ Sorry, we could not set your requested name because it contains a banned word.
+ 
+ Please try a different name.
+  </notification>
+
+  <notification
+   icon="alertmodal.tga"
+ name="AgentDisplayNameSetInvalidUnicode"
+ type="alertmodal">
+    The display name you wish to set contains invalid characters.
+  </notification>
+
+  <notification
+   icon="alertmodal.tga"
+ name="AgentDisplayNameSetOnlyPunctuation"
+ type="alertmodal">
+    Your display name must contain letters other than punctuation.
+  </notification>
+
+
+  <notification
+   icon="notifytip.tga"
+   name="DisplayNameUpdate"
+   type="notifytip">
+    [OLD_NAME] ([SLID]) is now known as [NEW_NAME].
+  </notification>
+
+<notification
  icon="notifytip.tga"
  name="Cancelled"
  type="notifytip">
@@ -5657,9 +5720,9 @@ If you want to view streaming media on parcels that support it you should go to
 No Media Plugin was found to handle the "[MIME_TYPE]" mime type.  Media of this type will be unavailable.
 </notification>
 <notification
- icon="alertmodal.tga"
+ icon="alert.tga"
  name="MediaPluginFailed"
- type="alertmodal">
+ type="alert">
 The following Media Plugin has failed:
 [PLUGIN]
 
@@ -6874,7 +6937,7 @@ GRAVITY  --  -9.8
 
 *  --  Multiplication
 \  --  Division
-+  --  Addition
+  --  Addition
 -  --  Subtraction
 
 For information about this feature, click "More Info".
@@ -6903,7 +6966,7 @@ GLOW --  Glow
 
 *  --  Multiplication
 \  --  Division
-+  --  Addition
+  --  Addition
 -  --  Subtraction
 
 For information about this feature, click "More Info".
@@ -7221,6 +7284,24 @@ Apply this region's settings? (&quot;Ignore&quot; will ignore all region setting
 The new font will appear after you restart [VIEWER_NAME].
 </notification>
 
+<notification
+ icon="alertmodal.tga"
+ name="FirstPrivacy"
+ type="alertmodal">
+Terms of service of the grid you are connecting to require sending a "statistics packet" every 5 minutes.
+That is for example: Data about your hardware (CPU, RAM), number of avatars around, number of sims visited.
+Please check *the grids* privacy policy about usage of that data.
+  <form name="form">
+          <button
+                 index="0"
+                 name="ok"
+                 text="Login anyway"/>
+          <button
+                 index="1"
+                 name="notok"
+                 text="Do not log in"/>
+  </form>
+</notification>
 
 <!--End Imprudence notifications-->
  <!-- [KITTY VIEWER] -->
diff --git a/linden/indra/newview/skins/default/xui/en-us/panel_avatar.xml b/linden/indra/newview/skins/default/xui/en-us/panel_avatar.xml
index 38c5a98..2db2595 100644
--- a/linden/indra/newview/skins/default/xui/en-us/panel_avatar.xml
+++ b/linden/indra/newview/skins/default/xui/en-us/panel_avatar.xml
@@ -127,6 +127,11 @@
                              font="SansSerifSmall" height="16" is_unicode="false" left="12"
                              max_length="254" mouse_opaque="false" name="name"
                              width="155" />
+      <name_editor bevel_style="in" border_style="line" visible="false"
+                             border_thickness="1" bottom="-24" enabled="false" follows="left|top"
+                             font="SansSerifSmall" height="16" is_unicode="false" left_delta="0"
+                             max_length="254" mouse_opaque="false" name="complete_name"
+                             width="155" />
       <button bottom_delta="0" font="SansSerif" halign="center" height="20"
            label="Copy Key" label_selected="Copy Key"
            left_delta="157" mouse_opaque="true" name="btn_copy_uuid" width="80" />
diff --git a/linden/indra/newview/skins/default/xui/en-us/panel_preferences_general.xml b/linden/indra/newview/skins/default/xui/en-us/panel_preferences_general.xml
index 4b0b292..6ced7d6 100644
--- a/linden/indra/newview/skins/default/xui/en-us/panel_preferences_general.xml
+++ b/linden/indra/newview/skins/default/xui/en-us/panel_preferences_general.xml
@@ -2,6 +2,15 @@
 <panel border="true" bottom="-409" enabled="true" follows="left|top|right|bottom"
      height="408" label="General" left="102" mouse_opaque="true"
      name="general_panel" width="517">
+        <text type="string" length="1" bg_visible="false" border_drop_shadow_visible="false" border_visible="false"
+             bottom="-20" drop_shadow_visible="true" enabled="true" follows="left|top"
+             font="SansSerifSmall" h_pad="0" halign="left" height="10" left="10"
+             mouse_opaque="true" name="start_location_textbox" v_pad="0" width="394">
+                Start Location:
+        </text>
+        <string name="region_name_prompt">
+                &lt;Type region name&gt;
+        </string>
   <combo_box name="default_location_combo"
              bottom="-22" left="155" height="16" width="150"
              follows="left|top" font="SansSerifSmall"
@@ -24,7 +33,13 @@
        font="SansSerifSmall" height="16" initial_value="true"
        label="Show start location at login screen" left="151" mouse_opaque="true"
        name="show_location_checkbox" radio_style="false" width="256" />
-        <combo_box bottom_delta="-25" follows="left|top" height="18" left="155"
+        <text type="string" length="1" bg_visible="false" border_drop_shadow_visible="false" border_visible="false"
+             bottom_delta="-24" drop_shadow_visible="true" enabled="true" follows="left|top"
+             font="SansSerifSmall" h_pad="0" halign="left" height="10" left="10"
+             mouse_opaque="true" name="show_names_textbox" v_pad="0" width="394">
+                Nametags:
+        </text>
+        <combo_box bottom_delta="0" follows="left|top" height="18" left="155"
              mouse_opaque="true" name="fade_out_combobox" width="146">
                 <combo_item name="Never" value="Never">
                         Never show
@@ -44,11 +59,35 @@
              font="SansSerifSmall" height="16" initial_value="false"
              label="Hide my name on my screen" left="151" name="show_my_name_checkbox"
              width="200" />
+
         <check_box bottom_delta="-20" follows="left|top"
              font="SansSerifSmall" height="16" initial_value="false"
              label="Highlight friends tags" left="151" name="highlight_friends_checkbox"
              width="200" />
         <text type="string" length="1" bottom_delta="-24" follows="left|top" font="SansSerifSmall" h_pad="0"
+             halign="left" height="16" left="10" name="Display_Names_textbox" v_pad="0"
+             width="394">
+                Display Names:
+        </text>
+        <radio_group name="displaynames" draw_border="false"
+               bottom_delta="0" left_delta="60" height="18"
+               follows="top|left"
+               control_name="DisplayNamesUsage">
+                <radio_item name="0" bottom_delta="-8" left_delta="40" height="18">
+                Legacy Names
+                </radio_item>
+                <radio_item name="1" bottom_delta="0" left_delta="50" height="18">
+                Display Names
+                </radio_item>
+                <radio_item name="2" bottom_delta="0" left_delta="50" height="18">
+                Show Both
+                </radio_item>
+        </radio_group>
+        <check_box bottom_delta="-20" follows="left|top" control_name="LegacyNamesForFriends"
+             font="SansSerifSmall" height="16" initial_value="false"
+             label="Show legacy names for friends" left="151" name="legacy_friends_checkbox"
+             width="200" />
+        <text type="string" length="1" bottom_delta="-24" follows="left|top" font="SansSerifSmall" h_pad="0"
              halign="left" height="16" left="10" name="group_titles_textbox" v_pad="0"
              width="394">
                 Group Titles:
@@ -61,37 +100,49 @@
              font="SansSerifSmall" height="16" initial_value="false"
              label="Hide my group title" left="330" name="show_my_title_checkbox"
              radio_style="false" width="256" />
-  <color_swatch border_color="0.45098 0.517647 0.607843 1" bottom="-210"
+        <text type="string" length="1" bg_visible="false" border_drop_shadow_visible="false" border_visible="false"
+             bottom_delta="-24" drop_shadow_visible="true" enabled="true" follows="left|top"
+             font="SansSerifSmall" h_pad="0" halign="left" height="10" left="10"
+             mouse_opaque="true" name="effects_color_textbox" v_pad="0" width="394">
+                Selection Beam Color:
+        </text>
+  <color_swatch border_color="0.45098 0.517647 0.607843 1" bottom_delta="-44"
              can_apply_immediately="false" color="1 1 1 1"
-             enabled="true" follows="left|top" height="65" label="" left="153"
+             enabled="true" follows="left|top" height="55" label="" left="153"
              mouse_opaque="true" name="effect_color_swatch"
-             tool_tip="Click to open Color Picker" width="55" />
+             tool_tip="Click to open Color Picker" width="45" />
   <text type="string" length="1" bg_visible="false" border_drop_shadow_visible="false" border_visible="false"
-             bottom="-215" drop_shadow_visible="true" enabled="true" follows="left|top"
+             bottom_delta="-18" drop_shadow_visible="true" enabled="true" follows="left|top"
              font="SansSerifSmall" h_pad="0" halign="left" height="12" left="10"
              mouse_opaque="true" name="UI Size:" v_pad="0" width="128">
     UI Size:
   </text>
-  <slider bottom="-217" can_edit_text="true"
+  <slider bottom_delta="42" can_edit_text="true"
              decimal_digits="3" enabled="true" height="16" increment="0.001"
              initial_val="1" left="148" max_val="1.4" min_val="0.75" mouse_opaque="true"
              name="ui_scale_slider" show_text="true" value="1" width="220" />
-  <button bottom="-221" enabled="true" follows="left|top"
+  <button bottom_delta="-48" enabled="true" follows="left|top"
              font="SansSerif" halign="center" height="22" label="Reset"
              label_selected="Reset" left_delta="226" mouse_opaque="true"
              name="reset_ui_size" scale_image="true" width="80" />
-  <check_box bottom="-236" enabled="true" follows="left|top"
+  <check_box bottom_delta="-14" enabled="true" follows="left|top"
              font="SansSerifSmall" height="16" initial_value="false"
              label="Use resolution independent scale" left="151" mouse_opaque="true"
              name="ui_auto_scale" radio_style="false" width="256" />
-  <check_box bottom="-260" enabled="true" follows="left|top"
-                   font="SansSerifSmall" height="16" initial_value="false"
-                   label="Go Away/AFK when idle" left="330" mouse_opaque="true"
-                   name="afk_timeout_checkbox" radio_style="false" width="256" />
-  <spinner bottom="-260" decimal_digits="0" enabled="true"
+  <spinner bottom_delta="-24" decimal_digits="0" enabled="true"
              follows="left|top" height="16" increment="1" initial_val="300"
              label="Away Timeout:" label_width="141" left="10" max_val="600"
              min_val="30" mouse_opaque="true" name="afk_timeout_spinner" width="202" />
+        <text type="string" length="1" bg_visible="false" border_drop_shadow_visible="false" border_visible="false"
+             bottom_delta="6" drop_shadow_visible="true" enabled="true" follows="left|top"
+             font="SansSerifSmall" h_pad="0" halign="left" height="10" left="220"
+             mouse_opaque="true" name="seconds_textbox" v_pad="0" width="128">
+                seconds
+        </text>
+    <check_box bottom_delta="-5" enabled="true" follows="left|top"
+                   font="SansSerifSmall" height="16" initial_value="false"
+                   label="Go Away/AFK when idle" left="330" mouse_opaque="true"
+                   name="afk_timeout_checkbox" radio_style="false" width="256" />
   <text type="string" length="1" bg_visible="false" border_drop_shadow_visible="false" border_visible="false"
        bottom_delta="-27" drop_shadow_visible="true" enabled="true" follows="left|top"
        font="SansSerifSmall" h_pad="0" halign="left" height="12" left="10"
@@ -109,18 +160,18 @@
        mouse_opaque="true" name="mini_map_notify_sim" radio_style="false"
        width="256" />
         <text type="string" length="1" bg_visible="false" border_drop_shadow_visible="false" border_visible="false"
-             bottom="-312" drop_shadow_visible="true" enabled="true" follows="left|top"
+             bottom_delta="-24" drop_shadow_visible="true" enabled="true" follows="left|top"
              font="SansSerifSmall" h_pad="0" halign="left" height="10" left="10"
              mouse_opaque="true" name="maturity_desired_label" v_pad="0" width="394">
                  Rating:
         </text>
         <text type="string" length="1" bg_visible="false" border_drop_shadow_visible="false" border_visible="false"
-             bottom="-312" drop_shadow_visible="true" enabled="true" follows="left|top"
+             bottom_delta="0" drop_shadow_visible="true" enabled="true" follows="left|top"
              font="SansSerifSmall" h_pad="0" halign="left" height="10" left="151"
              mouse_opaque="true" name="maturity_desired_prompt" v_pad="0" width="394">
                  I want to access content rated:
         </text>
-        <combo_box bottom="-318" follows="left|top" height="18" left="315"
+        <combo_box bottom_delta="-6" follows="left|top" height="18" left="315"
              mouse_opaque="true" name="maturity_desired_combobox" width="150">
                 <combo_item name="Desired_Adult" value="42">
                         PG, Mature and Adult
@@ -133,58 +184,20 @@
                 </combo_item>
         </combo_box>
         <text type="string" length="1" bg_visible="false" border_drop_shadow_visible="false" border_visible="false"
-             bottom="-312" drop_shadow_visible="true" enabled="true" follows="left|top"
+             bottom_delta="0" drop_shadow_visible="true" enabled="true" follows="left|top"
              font="SansSerifSmall" h_pad="0" halign="left" height="10" left="315"
              mouse_opaque="true" name="maturity_desired_textbox" v_pad="0" width="150">
                  PG only
         </text>
+
+
         <text type="string" length="1" bg_visible="false" border_drop_shadow_visible="false" border_visible="false"
-             bottom="-20" drop_shadow_visible="true" enabled="true" follows="left|top"
-             font="SansSerifSmall" h_pad="0" halign="left" height="10" left="10"
-             mouse_opaque="true" name="start_location_textbox" v_pad="0" width="394">
-                Start Location:
-        </text>
-        <text type="string" length="1" bg_visible="false" border_drop_shadow_visible="false" border_visible="false"
-             bottom="-64" drop_shadow_visible="true" enabled="true" follows="left|top"
-             font="SansSerifSmall" h_pad="0" halign="left" height="10" left="10"
-             mouse_opaque="true" name="show_names_textbox" v_pad="0" width="394">
-                Nametags:
-        </text>
-        <text type="string" length="1" bg_visible="false" border_drop_shadow_visible="false" border_visible="false"
-             bottom="-155" drop_shadow_visible="true" enabled="true" follows="left|top"
-             font="SansSerifSmall" h_pad="0" halign="left" height="10" left="10"
-             mouse_opaque="true" name="effects_color_textbox" v_pad="0" width="394">
-                Selection Beam Color:
-        </text>
-        <text type="string" length="1" bg_visible="false" border_drop_shadow_visible="false" border_visible="false"
-             bottom="-254" drop_shadow_visible="true" enabled="true" follows="left|top"
-             font="SansSerifSmall" h_pad="0" halign="left" height="10" left="220"
-             mouse_opaque="true" name="seconds_textbox" v_pad="0" width="128">
-                seconds
-        </text>
-        <text type="string" length="1" bg_visible="false" border_drop_shadow_visible="false" border_visible="false"
-             bottom="-352" drop_shadow_visible="true" enabled="true" follows="left|top"
+             bottom_delta="-24" drop_shadow_visible="true" enabled="true" follows="left|top"
              font="SansSerifSmall" h_pad="0" halign="left" height="18" left="10"
              mouse_opaque="true" name="time_textbox" v_pad="0" width="394">
                 Clock:
         </text>
-        <text type="string" length="1" bg_visible="false" border_drop_shadow_visible="false" border_visible="false"
-             bottom="-384" drop_shadow_visible="true" enabled="true" follows="left|top"
-             font="SansSerifSmall" h_pad="0" halign="left" height="18" left="10"
-             mouse_opaque="true" name="language_textbox" v_pad="0" width="394">
-                Language:
-        </text>
-        <text type="string" length="1" bg_visible="false" border_drop_shadow_visible="false" border_visible="false"
-             bottom_delta="-1" drop_shadow_visible="true" enabled="true"
-             follows="left|top" font="SansSerifSmall" h_pad="0" halign="left"
-             height="18" left_delta="293" mouse_opaque="true" name="language_textbox2"
-             v_pad="0" width="400">
-                (requires restart for full effect)
-        </text>
-        <string name="region_name_prompt">
-                &lt;Type region name&gt;
-        </string>
-        <combo_box allow_text_entry="false" bottom="-352" enabled="true" follows="left|top"
+        <combo_box allow_text_entry="false" bottom_delta="0" enabled="true" follows="left|top"
              height="18" left="153" max_chars="20" mouse_opaque="true"
              name="time_combobox" width="146">
                 <combo_item type="string" name="12HourTime" value="PST 12">
@@ -197,7 +210,13 @@
                         UTC
                 </combo_item>
         </combo_box>
-        <combo_box allow_text_entry="true" bottom="-382" enabled="true"
+        <text type="string" length="1" bg_visible="false" border_drop_shadow_visible="false" border_visible="false"
+             bottom_delta="-24" drop_shadow_visible="true" enabled="true" follows="left|top"
+             font="SansSerifSmall" h_pad="0" halign="left" height="18" left="10"
+             mouse_opaque="true" name="language_textbox" v_pad="0" width="394">
+                Language:
+        </text>
+        <combo_box allow_text_entry="true" bottom_delta="0" enabled="true"
              follows="left|top" height="16" left="153" max_chars="135"
              mouse_opaque="true" name="language_combobox" width="146">
                 <combo_item type="string" length="1" enabled="true" name="System Default Language" value="default">
@@ -255,5 +274,11 @@
                         한국어 (Korean) - Beta
                 </combo_item>
         </combo_box>
-
+        <text type="string" length="1" bg_visible="false" border_drop_shadow_visible="false" border_visible="false"
+             bottom_delta="0" drop_shadow_visible="true" enabled="true"
+             follows="left|top" font="SansSerifSmall" h_pad="0" halign="left"
+             height="18" left_delta="150" mouse_opaque="true" name="language_textbox2"
+             v_pad="0" width="400">
+                (requires restart for full effect)
+        </text>
 </panel>
diff --git a/linden/indra/newview/skins/default/xui/es/notifications.xml b/linden/indra/newview/skins/default/xui/es/notifications.xml
index f39dfc9..f3a862d 100644
--- a/linden/indra/newview/skins/default/xui/es/notifications.xml
+++ b/linden/indra/newview/skins/default/xui/es/notifications.xml
@@ -1454,21 +1454,6 @@ Se ocultará el chat y los mensajes instantáneos. Los mensajes instantáneos re
                         <button name="Cancel" text="Cancelar"/>
                 </form>
         </notification>
-        <notification label="Cambiar un estado Linden" name="ChangeLindenEstate">
-                Va a hacer cambios en un estado propiedad de Linden (mainland, grid teen, orientación, etc.).
-
-Esto es EXTREMADAMENTE PELIGROSO, porque puede afectar radicalmente al funcionamiento de los usuarios. En mainland, se cambiarán miles de regiones, y se provocará un colapso en el espacio del servidor.
-
-¿Proceder?
-                <usetemplate name="okcancelbuttons" notext="Cancelar" yestext="OK"/>
-        </notification>
-        <notification label="Cambiar el acceso a un estado Linden" name="ChangeLindenAccess">
-                Va a cambiar la lista de acceso de un estado propiedad de Linden (mainland, grid teen, orientación, etc.).
-
-Esto es PELIGROSO, y sólo debe hacerse para deshacerse de ataques que permitan sacar o meter en el grid objetos o L$.
-Se cambiarán miles de regiones, y se provocará un colapso en el espacio del servidor.
-                <usetemplate name="okcancelbuttons" notext="Cancelar" yestext="OK"/>
-        </notification>
         <notification label="Seleccionar el estado" name="EstateAllowedAgentAdd">
                 ¿Añadir a la lista de permitidos sólo para este estado o para [ALL_ESTATES]?
                 <usetemplate canceltext="Cancelar" name="yesnocancelbuttons" notext="Todos los estados" yestext="Este estado"/>
diff --git a/linden/indra/newview/skins/default/xui/fr/notifications.xml b/linden/indra/newview/skins/default/xui/fr/notifications.xml
index 6911f8b..dc7e61f 100644
--- a/linden/indra/newview/skins/default/xui/fr/notifications.xml
+++ b/linden/indra/newview/skins/default/xui/fr/notifications.xml
@@ -1425,21 +1425,6 @@ Pour quitter un groupe, sélectionnez l&apos;option Groupe dans le menu Éditer.
                         <button name="Cancel" text="Annuler"/>
                 </form>
         </notification>
-        <notification label="Modifier un domaine Linden" name="ChangeLindenEstate">
-                Vous vous apprêtez à modifier un domaine appartenant aux Lindens (continent, zone réservée aux ados, orientation etc.).
-
-Cela est extrêmement délicat car l&apos;expérience des résidents est en jeu. Sur le continent, cela modifiera des milliers de régions et sera difficile à digérer pour le serveur.
-
-Continuer ?
-                <usetemplate name="okcancelbuttons" notext="Annuler" yestext="OK"/>
-        </notification>
-        <notification label="Modifier l&apos;accès à un domaine Linden" name="ChangeLindenAccess">
-                Vous vous apprêtez à modifier la liste d&apos;accès à un domaine appartenant aux Linden (continent, zone réservée aux ados, orientation etc.).
-
-Cette action est délicate et ne doit être effectuée que pour appeler le hack autorisant des objets/L$ à être transférés à l&apos;intérieur/extérieur de la grille.
-Cette action modifiera des milliers de régions et sera difficile à digérer pour le serveur.
-                <usetemplate name="okcancelbuttons" notext="Annuler" yestext="OK"/>
-        </notification>
         <notification label="Choisir le domaine" name="EstateAllowedAgentAdd">
                 Ajouter à la liste des résidents autorisés uniquement pour ce domaine ou pour [ALL_ESTATES] ?
                 <usetemplate canceltext="Annuler" name="yesnocancelbuttons" notext="Tous les domaines" yestext="Ce domaine"/>
diff --git a/linden/indra/newview/skins/default/xui/hu/notifications.xml b/linden/indra/newview/skins/default/xui/hu/notifications.xml
index bf41284..6bc188d 100644
--- a/linden/indra/newview/skins/default/xui/hu/notifications.xml
+++ b/linden/indra/newview/skins/default/xui/hu/notifications.xml
@@ -1317,19 +1317,6 @@ A csoportból való kilépéshez válaszd a &apos;Csoportok...&apos; részt a &a
         <notification label="Üzenetküldés mindenki számára a telkeden" name="MessageEstate">
                 Rövid bejelentés írása, amely elküldésre mindenki részére, aki az ingatlanodon tartózkodik.
         </notification>
-        <notification label="Linden telek változtatása" name="ChangeLindenEstate">
-                Linden tulajdonú telek változtatása folyamatban (mainland, teen grid, orientation, stb.).
-
-Ez NAGYON VESZÉLYES, mivel kihatással van a felhasználók megszokásaira. A mainland-en ez régiók ezreit befolyásolja, amely a &apos;spaceserver&apos; működésében akadályokat okoz.
-
-Folytatod?
-        </notification>
-        <notification label="Linden telek belépésének változtatása" name="ChangeLindenAccess">
-                Linden tulajdonú telek változtatása folyamatban (mainland, teen grid, orientation, stb.).
-
-This is DANGEROUS and should only be done to invoke the hack allowing objects/L$ to be transfered in/out of a grid.
-A mainland-en ez régiók ezreit befolyásolja, amely a &apos;spaceserver&apos; működésében akadályokat okoz.
-        </notification>
         <notification label="Ingatlan kiválasztása" name="EstateAllowedAgentAdd">
                 Engedélyezettek listájához való hozzáadása csak ennek az ingatlan vagy [ALL_ESTATES] esetén?
         </notification>
diff --git a/linden/indra/newview/skins/default/xui/it/notifications.xml b/linden/indra/newview/skins/default/xui/it/notifications.xml
index 61aafae..039a6d1 100644
--- a/linden/indra/newview/skins/default/xui/it/notifications.xml
+++ b/linden/indra/newview/skins/default/xui/it/notifications.xml
@@ -1452,21 +1452,6 @@ Per abbandonare un gruppo seleziona l&apos;opzione &apos;Gruppi..&apos; dal menu
                         <button name="Cancel" text="Annulla"/>
                 </form>
         </notification>
-        <notification label="Cambia la tipologia della proprietà Linden" name="ChangeLindenEstate">
-                Stai per cambiare la tipologia della proprietà Linden (mainland, griglia minorenni, orientamento, ecc.).
-
-Questo è ESTREMAMENTE PERICOLOSO perchè può cambiare radicalmente l&apos;esperienza degli utenti.  Sulla mainland cambierà migliaia di regioni e produrrà seri problemi ai vari server.
-
-Confermi?
-                <usetemplate name="okcancelbuttons" notext="Annulla" yestext="OK"/>
-        </notification>
-        <notification label="Cambia la tipologia Linden di accesso alla proprietà" name="ChangeLindenAccess">
-                Stai per cambiare la lista di accesso per una proprietà Linden (mainland, griglia minorenni, orientamento, ecc.).
-
-Questo è PERICOLOSO e dovrebbe essere fatto soltanto per poter lanciare il programma che consente agli oggetti/L$ di essere trasferiti fra griglie diverse.
-Cambierà migliaia di regioni e produrrà seri problemi ai vari server.
-                <usetemplate name="okcancelbuttons" notext="Annulla" yestext="OK"/>
-        </notification>
         <notification label="Seleziona la proprietà" name="EstateAllowedAgentAdd">
                 Aggiungi alla lista di accesso solo per questa proprietà oppure per [ALL_ESTATES]?
                 <usetemplate canceltext="Annulla" name="yesnocancelbuttons" notext="Tutte le proprietà" yestext="Questa proprietà"/>
diff --git a/linden/indra/newview/skins/default/xui/ja/notifications.xml b/linden/indra/newview/skins/default/xui/ja/notifications.xml
index 6da6ccc..fa63cf0 100644
--- a/linden/indra/newview/skins/default/xui/ja/notifications.xml
+++ b/linden/indra/newview/skins/default/xui/ja/notifications.xml
@@ -1526,21 +1526,6 @@ F1キーを押してください。
                         <button name="Cancel" text="取り消し"/>
                 </form>
         </notification>
-        <notification label="Lindenの不動産を変更" name="ChangeLindenEstate">
-                あなたはLinden所有の不動産（メインランド、ティーングリッド、オリエンテーションなど）を変更しようとしています。
-
-これはユーザーの経験を根本から揺るがしかねない「非常に危険な行為」です。これにより、メインランドで多数の地域が変更され、スペースサーバーに悪影響が生じます。
-
-操作を続行しますか？
-                <usetemplate name="okcancelbuttons" notext="取り消し" yestext="OK"/>
-        </notification>
-        <notification label="Lindenの不動産へのアクセスを変更" name="ChangeLindenAccess">
-                あなたはLinden所有の不動産（メインランド、ティーングリッド、オリエンテーションなど）へのアクセスリストを変更しようとしています。
-
-この行為は「危険」であり、グリッドからオブジェクトやお金の転送をもたらすハッキングを引き起こす可能性があるため、完全にそれを意図した場合のみ行うべきものです。
-これにより多数の地域が変更され、スペースサーバーに悪影響が生じます。
-                <usetemplate name="okcancelbuttons" notext="取り消し" yestext="OK"/>
-        </notification>
         <notification label="不動産を選択" name="EstateAllowedAgentAdd">
                 この不動産の許可リストだけに追加しますか？ それとも[ALL_ESTATES]のすべての許可リストに追加しますか？
                 <usetemplate canceltext="取り消し" name="yesnocancelbuttons" notext="すべての不動産" yestext="この不動産"/>
diff --git a/linden/indra/newview/skins/default/xui/ko/notifications.xml b/linden/indra/newview/skins/default/xui/ko/notifications.xml
index cb720ed..20c57a1 100644
--- a/linden/indra/newview/skins/default/xui/ko/notifications.xml
+++ b/linden/indra/newview/skins/default/xui/ko/notifications.xml
@@ -2941,43 +2941,7 @@ Applications 폴더에 다운로드하시겠습니까?
     </form>
   </notification>
 
-  <notification
-   
-   label="린든 사유지 변경"
-   name="ChangeLindenEstate"
-   >
-귀하께서는 린든 소유의 사유지(메인랜드, 틴 그리드, 오리엔테이션 등)를
-변경하려고 합니다.
-
-이렇게 하면 기본적으로 사용자가 게임을 즐기는 데 영향을
-줄 수 있으므로 매우 위험합니다.  또한 메인랜드에서 수천가지의 지역이 변경되고
-공간 서버가 일시적으로 중단될 수도 있습니다.
-
-계속하시겠습니까?
-    <usetemplate
-     name="okcancelbuttons"
-     notext="취소"
-     yestext="사유지 변경"/>
-  </notification>
 
-  <notification
-   
-   label="린든 사유지 액세스 변경"
-   name="ChangeLindenAccess"
-   >
-귀하께서는 린든 소유의 사유지(메인랜드, 틴 그리드, 오리엔테이션 등)에 대한
-접근 목록을 변경하려고 합니다.
-
-이는 위험한 작업이며 오브젝트/금액을 그리드에서 송수신할 수 있도록
-핵을 불러내는 경우에만 수행할 수
-있습니다.
-이렇게 하면 수천가지의 지역이 변경되고
-공간 서버가 일시적으로 중단될 수도 있습니다.
-    <usetemplate
-     name="okcancelbuttons"
-     notext="취소"
-     yestext="사유지 변경"/>
-  </notification>
 
   <notification
    
diff --git a/linden/indra/newview/skins/default/xui/pl/notifications.xml b/linden/indra/newview/skins/default/xui/pl/notifications.xml
index 38a4b56..4c8ee5c 100644
--- a/linden/indra/newview/skins/default/xui/pl/notifications.xml
+++ b/linden/indra/newview/skins/default/xui/pl/notifications.xml
@@ -1434,23 +1434,6 @@ Musisz opuścić przynajmniej jedną grupę żeby przyjąć członkostwo w tej g
                         <button name="Cancel" text="Anuluj"/>
                 </form>
         </notification>
-        <notification label="Zmiana Majątku Lindenów" name="ChangeLindenEstate">
-                Dokonujesz zmiany w Regionie Głównym należącym do Lindenów (Regiony Główne, Teen Grid, Orientacja).
-                
-Żądana operacja jest wyjątkowo niebezpieczna dla wszystkich Rezydentów przebywających w regionie. Dodatkowo, zmiany dokonane w Regionie Głównym mogą spowodować problemy przestrzeni serwerowej innych regionów.
-
-Kontynuować?
-                <usetemplate name="okcancelbuttons" notext="Anuluj" yestext="OK"/>
-        </notification>
-        <notification label="Zmiana Dostępu do Majątku Lindenów" name="ChangeLindenAccess">
-                Dokonujesz zmiany w liście dostępu Regionu Głównego należącego do Lindenów (Regiony Główne, Teen Grid, Orientacja).
-
-Żądana operacja jest wyjątkowo niebezpieczna dla wszystkich Rezydentów przebywających w regionie i powinna być używana wyłącznie w celu zablokowania opcji pozwalającej na przeniesienie obiektów/L$ do/z sieci.
-Dodatkowo, zmiany dokonane w Regionie Głównym mogą spowodować problemy przestrzeni serwerowej innych regionów.
-
-Kontynuować?
-                <usetemplate name="okcancelbuttons" notext="Anuluj" yestext="OK"/>
-        </notification>
         <notification label="Wybierz Majątek" name="EstateAllowedAgentAdd">
                 Dodać do listy dostępu do tego majątku czy do [ALL_ESTATES]?
                 <usetemplate canceltext="Anuluj" name="yesnocancelbuttons" notext="Wszystkie majątki" yestext="Ten majątek"/>
diff --git a/linden/indra/newview/skins/default/xui/pt/notifications.xml b/linden/indra/newview/skins/default/xui/pt/notifications.xml
index 71903c1..a026c59 100644
--- a/linden/indra/newview/skins/default/xui/pt/notifications.xml
+++ b/linden/indra/newview/skins/default/xui/pt/notifications.xml
@@ -1434,21 +1434,6 @@ Bate-papo e mensagens instantâneas serão escondidas. Mensagens instantâneas i
                         <button name="Cancel" text="Cancelar"/>
                 </form>
         </notification>
-        <notification label="Mudar propriedade Linden" name="ChangeLindenEstate">
-                Você está prestes a mudar uma propriedade pertencente a Linden (continente, teen grid, orientação, etc.)
-
-Isto é EXTREMAMENTE PERIGOSO porque pode fundamentalmente afetar a experiência do usuário. No continente, vai mudar milhares de regiões e fazer o spaceserver soluçar.
-
-Proceder?
-                <usetemplate name="okcancelbuttons" notext="Cancelar" yestext="Mudar Propriedade"/>
-        </notification>
-        <notification label="Mudar o acesso à propriedade Linden" name="ChangeLindenAccess">
-                Você está prestes a mudar a lista de acessos de uma propriedade pertencente a Linden (continente, teen grid, orientação, etc.).
-
-Isto é PERIGOSO e deveria ser feito apenas para utilizar uma brecha que permita que objetos/L$ sejam transferidos para dentro/fora da grade.
-Isto mudará milhares de regiões e fará o spaceserver soluçar.
-                <usetemplate name="okcancelbuttons" notext="Cancelar" yestext="OK"/>
-        </notification>
         <notification label="Selecione a propriedade" name="EstateAllowedAgentAdd">
                 Adicionar à lista de permitidos somente para esta propriedade ou para [ALL_ESTATES]?
                 <usetemplate canceltext="Cancelar" name="yesnocancelbuttons" notext="Todas as Propriedades" yestext="Esta Propriedade"/>
diff --git a/linden/indra/newview/skins/default/xui/ru/notifications.xml b/linden/indra/newview/skins/default/xui/ru/notifications.xml
index 0d36371..e0f7740 100644
--- a/linden/indra/newview/skins/default/xui/ru/notifications.xml
+++ b/linden/indra/newview/skins/default/xui/ru/notifications.xml
@@ -1452,21 +1452,6 @@ www.secondlife.com/support
                         <button name="Cancel" text="Отмена"/>
                 </form>
         </notification>
-        <notification label="Изменить участок Линденов" name="ChangeLindenEstate">
-                Вы хотите сменить поместья, принадлежащие Линденам (материк, детский Grid, остров ориентации и т.д.).
-
-Это ЧРЕЗВЫЧАЙНО ОПАСНО, потому что это может существенно повлиять на положение вещей. На материке это может изменить тысячи регионов, и испортить работу серверов.
-
-Продолжить?
-                <usetemplate name="okcancelbuttons" notext="Отмена" yestext="OK"/>
-        </notification>
-        <notification label="Изменить доступ к участку Линденов" name="ChangeLindenAccess">
-                Вы хотите сменить поместья, принадлежащие Линденам (материк, детский Grid, остров ориентации и т.д.).
-
-Это ЧРЕЗВЫЧАЙНО ОПАСНО и может использоватся только для того, чтобы вызвать методы, позволяющие перемещать объекты/L$ в/из Grid.
-Это может изменить тысячи регионов, и испортить работу серверов.
-                <usetemplate name="okcancelbuttons" notext="Отмена" yestext="OK"/>
-        </notification>
         <notification label="Выбрать поместье" name="EstateAllowedAgentAdd">
                 Добавить в список разрешенных этого поместья или [ALL_ESTATES]?
                 <usetemplate canceltext="Отмена" name="yesnocancelbuttons" notext="Все поместья" yestext="Это поместье"/>
diff --git a/linden/indra/newview/skins/default/xui/uk/notifications.xml b/linden/indra/newview/skins/default/xui/uk/notifications.xml
index c7457b3..d207d02 100644
--- a/linden/indra/newview/skins/default/xui/uk/notifications.xml
+++ b/linden/indra/newview/skins/default/xui/uk/notifications.xml
@@ -1436,21 +1436,6 @@ www.secondlife.com/support
                         <button name="Cancel" text="Відміна"/>
                 </form>
         </notification>
-        <notification label="Змінити ділянку Лінденів" name="ChangeLindenEstate">
-                Ви хочете змінити маєтки, що належать Лінденам (материк, дитячий Grid, остров орієнтації і т.д.).
-
-Це НАДЗВИЧАЙНО НЕБЕЗПЕЧНО, тому що це може суттєво вплинути на стан речей. На материку це може змінити тисячі регіонів, і зіпсувати роботу серверів.
-
-Продовжити?
-                <usetemplate name="okcancelbuttons" notext="Відміна" yestext="OK"/>
-        </notification>
-        <notification label="Змінити доступ до ділянки Лінденів" name="ChangeLindenAccess">
-                Ви хочете змінити маєтки, що належать Лінденам (материк, дитячий Grid, остров орієнтації і т.д.).
-
-Це НАДЗВИЧАЙНО НЕБЕЗПЕЧНО і може використовуватися тільки для того, щоб викликати методи, що дозволять переміщати об&apos;єкти/L$ в/з Grid.
-Це може змінити тисячі регіонів, і зіпсувати роботу серверів.
-                <usetemplate name="okcancelbuttons" notext="Відміна" yestext="OK"/>
-        </notification>
         <notification label="Обрати маєток" name="EstateAllowedAgentAdd">
                 Додати в список дозволених цього маєтку або [ALL_ESTATES]?
                 <usetemplate canceltext="Відміна" name="yesnocancelbuttons" notext="Всі маєтки" yestext="Цей маєток"/>
diff --git a/linden/indra/newview/skins/default/xui/zh/notifications.xml b/linden/indra/newview/skins/default/xui/zh/notifications.xml
index acbb18b..415e5e7 100644
--- a/linden/indra/newview/skins/default/xui/zh/notifications.xml
+++ b/linden/indra/newview/skins/default/xui/zh/notifications.xml
@@ -1538,29 +1538,6 @@ www.secondlife.com/support
                         <button name="OK" text="确定"/>
                 </form>
         </notification>
-        <notification label="更改林登地产" name="ChangeLindenEstate">
-                你将要更改林登所有的地产(大陆、
-少年网格、方位岛，等等)。
-
- 这个动作极度危险，因为它可能会在基础的层次上
-影响到用户体验。在大陆上, 它将改变
-上千的区域，并会使空间服务器噎着。
-
-是否继续？
-                <usetemplate name="okcancelbuttons" notext="取消" yestext="更改不动产"/>
-        </notification>
-        <notification label="更改林登地产准入列表" name="ChangeLindenAccess">
-                你将要更改林登所有的地产的准入列表(大陆、
-少年网格、方位岛，等等)。
-
-该操作非常危险， 应该仅在利用把物体/金钱
-转移进或出某个网格的对付活儿 (hack) 时候
-才应该被执行。 它将改变上千的区域，并会
-使空间服务器噎着。
-
-是否继续？
-                <usetemplate name="okcancelbuttons" notext="取消" yestext="更改不动产"/>
-        </notification>
         <notification label="选择地产" name="EstateAllowedAgentAdd">
                 仅列入此地产还是[ALL_ESTATES]的允许名单？
                 <usetemplate canceltext="取消" name="yesnocancelbuttons" notext="所有地产" yestext="该地产"/>
diff --git a/linden/indra/test/lltemplatemessagebuilder_tut.cpp b/linden/indra/test/lltemplatemessagebuilder_tut.cpp
index 5b33d02..9fecc2f 100644
--- a/linden/indra/test/lltemplatemessagebuilder_tut.cpp
+++ b/linden/indra/test/lltemplatemessagebuilder_tut.cpp
@@ -35,7 +35,6 @@
 #include "linden_common.h"
 #include "lltut.h"
 
-#include "llapr.h"
 #include "llmessagetemplate.h"
 #include "llquaternion.h"
 #include "lltemplatemessagebuilder.h"
@@ -59,7 +58,6 @@ namespace tut
                         static bool init = false;
                         if(! init)
                         {
-                                ll_init_apr();
                                 const F32 circuit_heartbeat_interval=5;
                                 const F32 circuit_timeout=100;
 
diff --git a/linden/indra/test/message_tut.cpp b/linden/indra/test/message_tut.cpp
index 3fede26..694db52 100644
--- a/linden/indra/test/message_tut.cpp
+++ b/linden/indra/test/message_tut.cpp
@@ -35,7 +35,6 @@
 #include "linden_common.h"
 #include "lltut.h"
 
-#include "llapr.h"
 #include "llmessageconfig.h"
 #include "llsdserialize.h"
 #include "llversionserver.h"
@@ -68,7 +67,6 @@ namespace tut
                         static bool init = false;
                         if(!init)
                         {
-                                ll_init_apr();
                                 //init_prehash_data();
                                 init = true;
                         }
diff --git a/linden/indra/test/test.cpp b/linden/indra/test/test.cpp
index ba81c6e..b699f74 100644
--- a/linden/indra/test/test.cpp
+++ b/linden/indra/test/test.cpp
@@ -43,8 +43,8 @@
 #include "linden_common.h"
 #include "llerrorcontrol.h"
 #include "lltut.h"
+#include "aiaprpool.h"
 
-#include "apr_pools.h"
 #include "apr_getopt.h"
 
 // the CTYPE_WORKAROUND is needed for linux dev stations that don't
@@ -248,17 +248,12 @@ int main(int argc, char **argv)
         ctype_workaround();
 #endif
 
-        apr_initialize();
-        apr_pool_t* pool = NULL;
-        if(APR_SUCCESS != apr_pool_create(&pool, NULL))
-        {
-                std::cerr << "Unable to initialize pool" << std::endl;
-                return 1;
-        }
+        LLAPRPool pool;
+        pool.create();
         apr_getopt_t* os = NULL;
-        if(APR_SUCCESS != apr_getopt_init(&os, pool, argc, argv))
+        if(APR_SUCCESS != apr_getopt_init(&os, pool(), argc, argv))
         {
-                std::cerr << "Unable to  pool" << std::endl;
+                std::cerr << "Unable to initialize the arguments for parsing by apr_getopt()." << std::endl;
                 return 1;
         }
 
@@ -360,6 +355,5 @@ int main(int argc, char **argv)
                 s.close();
         }
         
-        apr_terminate();
         return 0;
 }
diff --git a/linden/indra/test_apps/llplugintest/demo_plugin.cpp b/linden/indra/test_apps/llplugintest/demo_plugin.cpp
index 772fa16..fd67a58 100644
--- a/linden/indra/test_apps/llplugintest/demo_plugin.cpp
+++ b/linden/indra/test_apps/llplugintest/demo_plugin.cpp
@@ -33,6 +33,8 @@
 #include "linden_common.h"
 
 #ifdef WIN32
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
 #include <windows.h>
 #endif
 
diff --git a/linden/indra/test_apps/llplugintest/llmediaplugintest.cpp b/linden/indra/test_apps/llplugintest/llmediaplugintest.cpp
index bc3703d..bf0a47b 100644
--- a/linden/indra/test_apps/llplugintest/llmediaplugintest.cpp
+++ b/linden/indra/test_apps/llplugintest/llmediaplugintest.cpp
@@ -190,9 +190,6 @@ LLMediaPluginTest::LLMediaPluginTest( int app_window, int window_width, int wind
                 std::cout << "Unable to read bookmarks from file: " << bookmarks_filename << std::endl;
         };
 
-        // initialize linden lab APR module
-        ll_init_apr();
-
         // Set up llerror logging 
         {
                 LLError::initForApplication(".");
diff --git a/linden/indra/win_crash_logger/StdAfx.h b/linden/indra/win_crash_logger/StdAfx.h
index 021a995..79198c2 100644
--- a/linden/indra/win_crash_logger/StdAfx.h
+++ b/linden/indra/win_crash_logger/StdAfx.h
@@ -46,6 +46,8 @@
 
 
 // Windows Header Files:
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
 #include <windows.h>
 
 // C RunTime Header Files
diff --git a/linden/indra/win_crash_logger/llcrashloggerwindows.h b/linden/indra/win_crash_logger/llcrashloggerwindows.h
index e6a9c77..f2a877e 100644
--- a/linden/indra/win_crash_logger/llcrashloggerwindows.h
+++ b/linden/indra/win_crash_logger/llcrashloggerwindows.h
@@ -34,6 +34,8 @@
 #define LLCRASHLOGGERWINDOWS_H
 
 #include "llcrashlogger.h"
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
 #include "windows.h"
 #include "llstring.h"
 
diff --git a/linden/indra/win_updater/updater.cpp b/linden/indra/win_updater/updater.cpp
index 117b8e8..481ef34 100644
--- a/linden/indra/win_updater/updater.cpp
+++ b/linden/indra/win_updater/updater.cpp
@@ -39,6 +39,8 @@
 // *TODO: Switch to fopen_s, strtok_s, etc.
 #define _CRT_SECURE_NO_DEPRECATE
 
+#       define WIN32_LEAN_AND_MEAN
+#       include <winsock2.h>
 #include <windows.h>
 #include <wininet.h>
 #include <stdio.h>
diff --git a/linden/install.xml b/linden/install.xml
index ec5090b..31d4c28 100755
--- a/linden/install.xml
+++ b/linden/install.xml
@@ -209,9 +209,9 @@
           <key>windows</key>
           <map>
             <key>md5sum</key>
-            <string>094acc8173faca882ed9532e868d767f</string>
+            <string>ed53511382d0fd9fec59a9f6544d9672</string>
             <key>url</key>
-            <uri>http://imprudenceviewer.org/download/libs/boost-1.36.0-windows-20091124.tar.bz2</uri>
+            <uri>http://s3.amazonaws.com/viewer-source-downloads/install_pkgs/boost-1.39.0-windows-20091029.tar.bz2</uri>
           </map>
         </map>
       </map>
@@ -1284,6 +1284,13 @@ Copyright (C) 2004-2005 Vladimir Berezniker @ http://public.xdi.org/=vmpn
             <key>url</key>
             <uri>http://s3.amazonaws.com/viewer-source-downloads/install_pkgs/linux-pulse-headers-0.9.14.tar.bz2</uri>
           </map>
+          <key>linux64</key>
+          <map>
+            <key>md5sum</key>
+            <string>30cb00069fe2a545fbf7be1070386236</string>
+            <key>url</key>
+            <uri>http://s3.amazonaws.com/viewer-source-downloads/install_pkgs/linux-pulse-headers-0.9.14.tar.bz2</uri>
+          </map>
         </map>
       </map>
       <key>quicktime</key>