svn merge -r114679:114681 svn+ssh://svn.lindenlab.com/svn/linden/branches/event-system/event-system-7 svn+ssh://svn.lindenlab.com/svn/linden/branches/event-system/event-system-8

25 files changed, 849 insertions, 164 deletions

diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt
index 9533281688..e1f545adb5 100644
--- a/indra/newview/CMakeLists.txt
+++ b/indra/newview/CMakeLists.txt
@@ -80,6 +80,7 @@ set(viewer_SOURCE_FILES
     llbox.cpp
     llcallbacklist.cpp
     llcallingcard.cpp
+    llcapabilitylistener.cpp
     llcaphttpsender.cpp
     llchatbar.cpp
     llclassifiedinfo.cpp
@@ -474,6 +475,8 @@ set(viewer_HEADER_FILES
     llbox.h
     llcallbacklist.h
     llcallingcard.h
+    llcapabilitylistener.h
+    llcapabilityprovider.h
     llcaphttpsender.h
     llchatbar.h
     llclassifiedinfo.h
@@ -1385,3 +1388,5 @@ if (INSTALL)
 endif (INSTALL)
 
 ADD_VIEWER_BUILD_TEST(llagentaccess viewer)
+ADD_VIEWER_COMM_BUILD_TEST(llcapabilitylistener viewer 
+  ${CMAKE_CURRENT_SOURCE_DIR}/../llmessage/tests/test_llsdmessage_peer.py)
diff --git a/indra/newview/llagent.cpp b/indra/newview/llagent.cpp
index 263c2b52bf..f97f9f607f 100644
--- a/indra/newview/llagent.cpp
+++ b/indra/newview/llagent.cpp
@@ -136,6 +136,8 @@
 #include "llviewerjoystick.h"
 #include "llfollowcam.h"
 #include "lltrans.h"
+#include "stringize.h"
+#include "llcapabilitylistener.h"
 
 #include "llnavigationbar.h" //to show/hide navigation bar when changing mouse look state
 
@@ -947,7 +949,7 @@ LLViewerRegion *LLAgent::getRegion() const
 }
 
 
-const LLHost& LLAgent::getRegionHost() const
+LLHost LLAgent::getRegionHost() const
 {
 	if (mRegionp)
 	{
@@ -4699,109 +4701,128 @@ void LLAgent::lookAtLastChat()
 
 const F32 SIT_POINT_EXTENTS = 0.2f;
 
+LLSD ll_sdmap_from_vector3(const LLVector3& vec)
+{
+    LLSD ret;
+    ret["X"] = vec.mV[VX];
+    ret["Y"] = vec.mV[VY];
+    ret["Z"] = vec.mV[VZ];
+    return ret;
+}
+
+LLVector3 ll_vector3_from_sdmap(const LLSD& sd)
+{
+    LLVector3 ret;
+    ret.mV[VX] = F32(sd["X"].asReal());
+    ret.mV[VY] = F32(sd["Y"].asReal());
+    ret.mV[VZ] = F32(sd["Z"].asReal());
+    return ret;
+}
+
 void LLAgent::setStartPosition( U32 location_id )
 {
-  LLViewerObject          *object;
+    LLViewerObject          *object;
 
-  if ( !(gAgentID == LLUUID::null) )
-  {
+    if (gAgentID == LLUUID::null)
+    {
+        return;
+    }
     // we've got an ID for an agent viewerobject
     object = gObjectList.findObject(gAgentID);
-    if (object)
+    if (! object)
     {
-      // we've got the viewer object
-      // Sometimes the agent can be velocity interpolated off of
-      // this simulator.  Clamp it to the region the agent is
-      // in, a little bit in on each side.
-      const F32 INSET = 0.5f; //meters
-      const F32 REGION_WIDTH = LLWorld::getInstance()->getRegionWidthInMeters();
-
-      LLVector3 agent_pos = getPositionAgent();
-      LLVector3 agent_look_at = mFrameAgent.getAtAxis();
-
-      if (mAvatarObject.notNull())
-      {
-	// the z height is at the agent's feet
-	agent_pos.mV[VZ] -= 0.5f * mAvatarObject->mBodySize.mV[VZ];
-      }
-
-      agent_pos.mV[VX] = llclamp( agent_pos.mV[VX], INSET, REGION_WIDTH - INSET );
-      agent_pos.mV[VY] = llclamp( agent_pos.mV[VY], INSET, REGION_WIDTH - INSET );
-
-      // Don't let them go below ground, or too high.
-      agent_pos.mV[VZ] = llclamp( agent_pos.mV[VZ],
-				  mRegionp->getLandHeightRegion( agent_pos ),
-				  LLWorld::getInstance()->getRegionMaxHeight() );
-      // Send the CapReq
-
-      LLSD body;
-
-      std::string url = gAgent.getRegion()->getCapability("HomeLocation");
-      std::ostringstream strBuffer;
-      if( url.empty() )
-      {
-	LLMessageSystem* msg = gMessageSystem;
-	msg->newMessageFast(_PREHASH_SetStartLocationRequest);
-	msg->nextBlockFast( _PREHASH_AgentData);
-	msg->addUUIDFast(_PREHASH_AgentID, getID());
-	msg->addUUIDFast(_PREHASH_SessionID, getSessionID());
-	msg->nextBlockFast( _PREHASH_StartLocationData);
-	// corrected by sim
-	msg->addStringFast(_PREHASH_SimName, "");
-	msg->addU32Fast(_PREHASH_LocationID, location_id);
-	msg->addVector3Fast(_PREHASH_LocationPos, agent_pos);
-	msg->addVector3Fast(_PREHASH_LocationLookAt,mFrameAgent.getAtAxis());
-	
-	// Reliable only helps when setting home location.  Last
-	// location is sent on quit, and we don't have time to ack
-	// the packets.
-	msg->sendReliable(mRegionp->getHost());
-
-	const U32 HOME_INDEX = 1;
-	if( HOME_INDEX == location_id )
-	  {
-	    setHomePosRegion( mRegionp->getHandle(), getPositionAgent() );
-	  }
-      }
-      else
-      {
-	strBuffer << location_id;
-	body["HomeLocation"]["LocationId"] = strBuffer.str();
-
-	strBuffer.str("");
-	strBuffer << agent_pos.mV[VX];
-	body["HomeLocation"]["LocationPos"]["X"] = strBuffer.str();
-
-	strBuffer.str("");
-	strBuffer << agent_pos.mV[VY];
-	body["HomeLocation"]["LocationPos"]["Y"] = strBuffer.str();
-
-	strBuffer.str("");
-	strBuffer << agent_pos.mV[VZ];
-	body["HomeLocation"]["LocationPos"]["Z"] = strBuffer.str();
-
-	strBuffer.str("");
-	strBuffer << agent_look_at.mV[VX];
-	body["HomeLocation"]["LocationLookAt"]["X"] = strBuffer.str();
-
-	strBuffer.str("");
-	strBuffer << agent_look_at.mV[VY];
-	body["HomeLocation"]["LocationLookAt"]["Y"] = strBuffer.str();
-
-	strBuffer.str("");
-	strBuffer << agent_look_at.mV[VZ];
-	body["HomeLocation"]["LocationLookAt"]["Z"] = strBuffer.str();
-
-	LLHTTPClient::post( url, body, new LLHomeLocationResponder() );
-      }
+        llinfos << "setStartPosition - Can't find agent viewerobject id " << gAgentID << llendl;
+        return;
+    }
+    // we've got the viewer object
+    // Sometimes the agent can be velocity interpolated off of
+    // this simulator.  Clamp it to the region the agent is
+    // in, a little bit in on each side.
+    const F32 INSET = 0.5f; //meters
+    const F32 REGION_WIDTH = LLWorld::getInstance()->getRegionWidthInMeters();
+
+    LLVector3 agent_pos = getPositionAgent();
+
+    if (mAvatarObject.notNull())
+    {
+        // the z height is at the agent's feet
+        agent_pos.mV[VZ] -= 0.5f * mAvatarObject->mBodySize.mV[VZ];
     }
-    else
+
+    agent_pos.mV[VX] = llclamp( agent_pos.mV[VX], INSET, REGION_WIDTH - INSET );
+    agent_pos.mV[VY] = llclamp( agent_pos.mV[VY], INSET, REGION_WIDTH - INSET );
+
+    // Don't let them go below ground, or too high.
+    agent_pos.mV[VZ] = llclamp( agent_pos.mV[VZ],
+                                mRegionp->getLandHeightRegion( agent_pos ),
+                                LLWorld::getInstance()->getRegionMaxHeight() );
+    // Send the CapReq
+    LLSD request;
+    LLSD body;
+    LLSD homeLocation;
+
+    homeLocation["LocationId"] = LLSD::Integer(location_id);
+    homeLocation["LocationPos"] = ll_sdmap_from_vector3(agent_pos);
+    homeLocation["LocationLookAt"] = ll_sdmap_from_vector3(mFrameAgent.getAtAxis());
+
+    body["HomeLocation"] = homeLocation;
+
+    // This awkward idiom warrants explanation.
+    // For starters, LLSDMessage::ResponderAdapter is ONLY for testing the new
+    // LLSDMessage functionality with a pre-existing LLHTTPClient::Responder.
+    // In new code, define your reply/error methods on the same class as the
+    // sending method, bind them to local LLEventPump objects and pass those
+    // LLEventPump names in the request LLSD object.
+    // When testing old code, the new LLHomeLocationResponder object
+    // is referenced by an LLHTTPClient::ResponderPtr, so when the
+    // ResponderAdapter is deleted, the LLHomeLocationResponder will be too.
+    // We must trust that the underlying LLHTTPClient code will eventually
+    // fire either the reply callback or the error callback; either will cause
+    // the ResponderAdapter to delete itself.
+    LLSDMessage::ResponderAdapter*
+        adapter(new LLSDMessage::ResponderAdapter(new LLHomeLocationResponder()));
+
+    request["message"] = "HomeLocation";
+    request["payload"] = body;
+    request["reply"]   = adapter->getReplyName();
+    request["error"]   = adapter->getErrorName();
+
+    gAgent.getRegion()->getCapAPI().post(request);
+
+    const U32 HOME_INDEX = 1;
+    if( HOME_INDEX == location_id )
     {
-      llinfos << "setStartPosition - Can't find agent viewerobject id " << gAgentID << llendl;
+        setHomePosRegion( mRegionp->getHandle(), getPositionAgent() );
     }
-  }
 }
 
+struct HomeLocationMapper: public LLCapabilityListener::CapabilityMapper
+{
+    // No reply message expected
+    HomeLocationMapper(): LLCapabilityListener::CapabilityMapper("HomeLocation") {}
+    virtual void buildMessage(LLMessageSystem* msg,
+                              const LLUUID& agentID,
+                              const LLUUID& sessionID,
+                              const std::string& capabilityName,
+                              const LLSD& payload) const
+    {
+        msg->newMessageFast(_PREHASH_SetStartLocationRequest);
+        msg->nextBlockFast( _PREHASH_AgentData);
+        msg->addUUIDFast(_PREHASH_AgentID, agentID);
+        msg->addUUIDFast(_PREHASH_SessionID, sessionID);
+        msg->nextBlockFast( _PREHASH_StartLocationData);
+        // corrected by sim
+        msg->addStringFast(_PREHASH_SimName, "");
+        msg->addU32Fast(_PREHASH_LocationID, payload["HomeLocation"]["LocationId"].asInteger());
+        msg->addVector3Fast(_PREHASH_LocationPos,
+                            ll_vector3_from_sdmap(payload["HomeLocation"]["LocationPos"]));
+        msg->addVector3Fast(_PREHASH_LocationLookAt,
+                            ll_vector3_from_sdmap(payload["HomeLocation"]["LocationLookAt"]));
+    }
+};
+// Need an instance of this class so it will self-register
+static HomeLocationMapper homeLocationMapper;
+
 void LLAgent::requestStopMotion( LLMotion* motion )
 {
 	// Notify all avatars that a motion has stopped.
@@ -5479,7 +5500,7 @@ void update_group_floaters(const LLUUID& group_id)
 		gIMMgr->refresh();
 	}
 
-	gAgent.fireEvent(new LLEvent(&gAgent, "new group"), "");
+	gAgent.fireEvent(new LLOldEvents::LLEvent(&gAgent, "new group"), "");
 }
 
 // static
diff --git a/indra/newview/llagent.h b/indra/newview/llagent.h
index 3174357a1a..23ff6cd594 100644
--- a/indra/newview/llagent.h
+++ b/indra/newview/llagent.h
@@ -119,7 +119,7 @@ inline bool operator==(const LLGroupData &a, const LLGroupData &b)
 
 //
 
-class LLAgent : public LLObservable
+class LLAgent : public LLOldEvents::LLObservable
 {
 	LOG_CLASS(LLAgent);
 	
@@ -176,7 +176,7 @@ public:
 	// Set the home data
 	void			setRegion(LLViewerRegion *regionp);
 	LLViewerRegion	*getRegion() const;
-	const LLHost&	getRegionHost() const;
+	LLHost			getRegionHost() const;
 	std::string		getSLURL() const;
 	
 	void			updateAgentPosition(const F32 dt, const F32 yaw, const S32 mouse_x, const S32 mouse_y);		// call once per frame to update position, angles radians
diff --git a/indra/newview/llagentlanguage.h b/indra/newview/llagentlanguage.h
index e313837883..45348a1e50 100644
--- a/indra/newview/llagentlanguage.h
+++ b/indra/newview/llagentlanguage.h
@@ -36,7 +36,7 @@
 #include "llsingleton.h"	// LLSingleton<>
 #include "llevent.h"
 
-class LLAgentLanguage: public LLSingleton<LLAgentLanguage>, public LLSimpleListener
+class LLAgentLanguage: public LLSingleton<LLAgentLanguage>, public LLOldEvents::LLSimpleListener
 {
  public:
 	LLAgentLanguage();
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index a613e6a14b..073b6b85fc 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -96,6 +96,7 @@
 #include "lltexturecache.h"
 #include "lltexturefetch.h"
 #include "llimageworker.h"
+#include "llevents.h"
 
 // The files below handle dependencies from cleanup.
 #include "llkeyframemotion.h"
@@ -841,7 +842,14 @@ bool LLAppViewer::mainLoop()
 	LLTimer debugTime;
 	LLViewerJoystick* joystick(LLViewerJoystick::getInstance());
 	joystick->setNeedsReset(true);
- 	
+
+    LLEventPump& mainloop(LLEventPumps::instance().obtain("mainloop"));
+    // As we do not (yet) send data on the mainloop LLEventPump that varies
+    // with each frame, no need to instantiate a new LLSD event object each
+    // time. Obviously, if that changes, just instantiate the LLSD at the
+    // point of posting.
+    LLSD newFrame;
+
 	// Handle messages
 	while (!LLApp::isExiting())
 	{
@@ -884,6 +892,9 @@ bool LLAppViewer::mainLoop()
 				LLFloaterMemLeak::getInstance()->idle() ;				
 			}			
 
+            // canonical per-frame event
+            mainloop.post(newFrame);
+
 			if (!LLApp::isExiting())
 			{
 				pingMainloopTimeout("Main:JoystickKeyboard");
diff --git a/indra/newview/llcapabilitylistener.cpp b/indra/newview/llcapabilitylistener.cpp
new file mode 100644
index 0000000000..3277da8930
--- /dev/null
+++ b/indra/newview/llcapabilitylistener.cpp
@@ -0,0 +1,183 @@
+/**
+ * @file   llcapabilitylistener.cpp
+ * @author Nat Goodspeed
+ * @date   2009-01-07
+ * @brief  Implementation for llcapabilitylistener.
+ * 
+ * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * Copyright (c) 2009, Linden Research, Inc.
+ * $/LicenseInfo$
+ */
+
+// Precompiled header
+#include "llviewerprecompiledheaders.h"
+// associated header
+#include "llcapabilitylistener.h"
+// STL headers
+#include <map>
+// std headers
+// external library headers
+#include <boost/bind.hpp>
+// other Linden headers
+#include "stringize.h"
+#include "llcapabilityprovider.h"
+
+class LLCapabilityListener::CapabilityMappers: public LLSingleton<LLCapabilityListener::CapabilityMappers>
+{
+public:
+    void registerMapper(const LLCapabilityListener::CapabilityMapper*);
+    void unregisterMapper(const LLCapabilityListener::CapabilityMapper*);
+    const LLCapabilityListener::CapabilityMapper* find(const std::string& cap) const;
+
+    struct DupCapMapper: public std::runtime_error
+    {
+        DupCapMapper(const std::string& what):
+            std::runtime_error(std::string("DupCapMapper: ") + what)
+        {}
+    };
+
+private:
+    friend class LLSingleton<LLCapabilityListener::CapabilityMappers>;
+    CapabilityMappers();
+
+    typedef std::map<std::string, const LLCapabilityListener::CapabilityMapper*> CapabilityMap;
+    CapabilityMap mMap;
+};
+
+LLCapabilityListener::LLCapabilityListener(const std::string& name,
+                                           LLMessageSystem* messageSystem,
+                                           const LLCapabilityProvider& provider,
+                                           const LLUUID& agentID,
+                                           const LLUUID& sessionID):
+    mEventPump(name),
+    mMessageSystem(messageSystem),
+    mProvider(provider),
+    mAgentID(agentID),
+    mSessionID(sessionID)
+{
+    mEventPump.listen("self", boost::bind(&LLCapabilityListener::capListener, this, _1));
+}
+
+bool LLCapabilityListener::capListener(const LLSD& request)
+{
+    // Extract what we want from the request object. We do it all up front
+    // partly to document what we expect.
+    LLSD::String cap(request["message"]);
+    LLSD payload(request["payload"]);
+    LLSD::String reply(request["reply"]);
+    LLSD::String error(request["error"]);
+    LLSD::Real timeout(request["timeout"]);
+    // If the LLSD doesn't even have a "message" key, we doubt it was intended
+    // for this listener.
+    if (cap.empty())
+    {
+        LL_ERRS("capListener") << "capability request event without 'message' key to '"
+                               << getCapAPI().getName()
+                               << "' on region\n" << mProvider.getDescription()
+                               << LL_ENDL;
+        return false;               // in case fatal-error function isn't
+    }
+    // Establish default timeout. This test relies on LLSD::asReal() returning
+    // exactly 0.0 for an undef value.
+    if (! timeout)
+    {
+        timeout = HTTP_REQUEST_EXPIRY_SECS;
+    }
+    // Look up the url for the requested capability name.
+    std::string url = mProvider.getCapability(cap);
+    if (! url.empty())
+    {
+        // This capability is supported by the region to which we're talking.
+        LLHTTPClient::post(url, payload,
+                           new LLSDMessage::EventResponder(LLEventPumps::instance(),
+                                                           mProvider.getDescription(),
+                                                           cap, reply, error),
+                           LLSD(),  // headers
+                           timeout);
+    }
+    else
+    {
+        // Capability not supported -- do we have a registered mapper?
+        const CapabilityMapper* mapper = CapabilityMappers::instance().find(cap);
+        if (! mapper)               // capability neither supported nor mapped
+        {
+            LL_ERRS("capListener") << "unsupported capability '" << cap << "' request to '"
+                                   << getCapAPI().getName() << "' on region\n"
+                                   << mProvider.getDescription()
+                                   << LL_ENDL;
+        }
+        else if (! mapper->getReplyName().empty()) // mapper expects reply support
+        {
+            LL_ERRS("capListener") << "Mapper for capability '" << cap
+                                   << "' requires unimplemented support for reply message '"
+                                   << mapper->getReplyName()
+                                   << "' on '" << getCapAPI().getName() << "' on region\n"
+                                   << mProvider.getDescription()
+                                   << LL_ENDL;
+        }
+        else
+        {
+            LL_INFOS("capListener") << "fallback invoked for capability '" << cap
+                                    << "' request to '" << getCapAPI().getName()
+                                    << "' on region\n" << mProvider.getDescription()
+                                    << LL_ENDL;
+            mapper->buildMessage(mMessageSystem, mAgentID, mSessionID, cap, payload);
+            mMessageSystem->sendReliable(mProvider.getHost());
+        }
+    }
+    return false;
+}
+
+LLCapabilityListener::CapabilityMapper::CapabilityMapper(const std::string& cap, const std::string& reply):
+    mCapName(cap),
+    mReplyName(reply)
+{
+    LLCapabilityListener::CapabilityMappers::instance().registerMapper(this);
+}
+
+LLCapabilityListener::CapabilityMapper::~CapabilityMapper()
+{
+    LLCapabilityListener::CapabilityMappers::instance().unregisterMapper(this);
+}
+
+LLSD LLCapabilityListener::CapabilityMapper::readResponse(LLMessageSystem* messageSystem) const
+{
+    return LLSD();
+}
+
+LLCapabilityListener::CapabilityMappers::CapabilityMappers() {}
+
+void LLCapabilityListener::CapabilityMappers::registerMapper(const LLCapabilityListener::CapabilityMapper* mapper)
+{
+    // Try to insert a new map entry by which we can look up the passed mapper
+    // instance.
+    std::pair<CapabilityMap::iterator, bool> inserted =
+        mMap.insert(CapabilityMap::value_type(mapper->getCapName(), mapper));
+    // If we already have a mapper for that name, insert() merely located the
+    // existing iterator and returned false. It is a coding error to try to
+    // register more than one mapper for the same capability name.
+    if (! inserted.second)
+    {
+        throw DupCapMapper(std::string("Duplicate capability name ") + mapper->getCapName());
+    }
+}
+
+void LLCapabilityListener::CapabilityMappers::unregisterMapper(const LLCapabilityListener::CapabilityMapper* mapper)
+{
+    CapabilityMap::iterator found = mMap.find(mapper->getCapName());
+    if (found != mMap.end())
+    {
+        mMap.erase(found);
+    }
+}
+
+const LLCapabilityListener::CapabilityMapper*
+LLCapabilityListener::CapabilityMappers::find(const std::string& cap) const
+{
+    CapabilityMap::const_iterator found = mMap.find(cap);
+    if (found != mMap.end())
+    {
+        return found->second;
+    }
+    return NULL;
+}
diff --git a/indra/newview/llcapabilitylistener.h b/indra/newview/llcapabilitylistener.h
new file mode 100644
index 0000000000..061227e04d
--- /dev/null
+++ b/indra/newview/llcapabilitylistener.h
@@ -0,0 +1,113 @@
+/**
+ * @file   llcapabilitylistener.h
+ * @author Nat Goodspeed
+ * @date   2009-01-07
+ * @brief  Provide an event-based API for capability requests
+ * 
+ * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * Copyright (c) 2009, Linden Research, Inc.
+ * $/LicenseInfo$
+ */
+
+#if ! defined(LL_LLCAPABILITYLISTENER_H)
+#define LL_LLCAPABILITYLISTENER_H
+
+#include "llevents.h"               // LLEventPump
+#include "llsdmessage.h"            // LLSDMessage::ArgError
+#include "llerror.h"                // LOG_CLASS()
+
+class LLCapabilityProvider;
+class LLSD;
+
+class LLCapabilityListener
+{
+    LOG_CLASS(LLCapabilityListener);
+public:
+    LLCapabilityListener(const std::string& name, LLMessageSystem* messageSystem,
+                         const LLCapabilityProvider& provider,
+                         const LLUUID& agentID, const LLUUID& sessionID);
+
+    /// Capability-request exception
+    typedef LLSDMessage::ArgError ArgError;
+    /// Get LLEventPump on which we listen for capability requests
+    /// (https://wiki.lindenlab.com/wiki/Viewer:Messaging/Messaging_Notes#Capabilities)
+    LLEventPump& getCapAPI() { return mEventPump; }
+
+    /**
+     * Base class for mapping an as-yet-undeployed capability name to a (pair
+     * of) LLMessageSystem message(s). To map a capability name to such
+     * messages, derive a subclass of CapabilityMapper and declare a static
+     * instance in a translation unit known to be loaded. The mapping is not
+     * region-specific. If an LLViewerRegion's capListener() receives a
+     * request for a supported capability, it will use the capability's URL.
+     * If not, it will look for an applicable CapabilityMapper subclass
+     * instance.
+     */
+    class CapabilityMapper
+    {
+    public:
+        /**
+         * Base-class constructor. Typically your subclass constructor will
+         * pass these parameters as literals.
+         * @param cap the capability name handled by this (subclass) instance
+         * @param reply the name of the response LLMessageSystem message. Omit
+         * if the LLMessageSystem message you intend to send doesn't prompt a
+         * reply message, or if you already handle that message in some other
+         * way.
+         */
+        CapabilityMapper(const std::string& cap, const std::string& reply = "");
+        virtual ~CapabilityMapper();
+        /// query the capability name
+        std::string getCapName() const { return mCapName; }
+        /// query the reply message name
+        std::string getReplyName() const { return mReplyName; }
+        /**
+         * Override this method to build the LLMessageSystem message we should
+         * send instead of the requested capability message. DO NOT send that
+         * message: that will be handled by the caller.
+         */
+        virtual void buildMessage(LLMessageSystem* messageSystem,
+                                  const LLUUID& agentID,
+                                  const LLUUID& sessionID,
+                                  const std::string& capabilityName,
+                                  const LLSD& payload) const = 0;
+        /**
+         * Override this method if you pass a non-empty @a reply
+         * LLMessageSystem message name to the constructor: that is, if you
+         * expect to receive an LLMessageSystem message in response to the
+         * message you constructed in buildMessage(). If you don't pass a @a
+         * reply message name, you need not override this method as it won't
+         * be called.
+         *
+         * Using LLMessageSystem message-reading operations, your
+         * readResponse() override should construct and return an LLSD object
+         * of the form you expect to receive from the real implementation of
+         * the capability you intend to invoke, when it finally goes live.
+         */
+        virtual LLSD readResponse(LLMessageSystem* messageSystem) const;
+
+    private:
+        const std::string mCapName;
+        const std::string mReplyName;
+    };
+
+private:
+    /// Bind the LLCapabilityProvider passed to our ctor
+    const LLCapabilityProvider& mProvider;
+
+    /// Post an event to this LLEventPump to invoke a capability message on
+    /// the bound LLCapabilityProvider's server
+    /// (https://wiki.lindenlab.com/wiki/Viewer:Messaging/Messaging_Notes#Capabilities)
+    LLEventStream mEventPump;
+
+    LLMessageSystem* mMessageSystem;
+    LLUUID mAgentID, mSessionID;
+
+    /// listener to process capability requests
+    bool capListener(const LLSD&);
+
+    /// helper class for capListener()
+    class CapabilityMappers;
+};
+
+#endif /* ! defined(LL_LLCAPABILITYLISTENER_H) */
diff --git a/indra/newview/llcapabilityprovider.h b/indra/newview/llcapabilityprovider.h
new file mode 100644
index 0000000000..0ddb2b6cb9
--- /dev/null
+++ b/indra/newview/llcapabilityprovider.h
@@ -0,0 +1,39 @@
+/**
+ * @file   llcapabilityprovider.h
+ * @author Nat Goodspeed
+ * @date   2009-01-07
+ * @brief  Interface by which to reference (e.g.) LLViewerRegion to obtain a
+ *         capability.
+ * 
+ * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * Copyright (c) 2009, Linden Research, Inc.
+ * $/LicenseInfo$
+ */
+
+#if ! defined(LL_LLCAPABILITYPROVIDER_H)
+#define LL_LLCAPABILITYPROVIDER_H
+
+#include "llhost.h"
+#include <string>
+
+/// Interface for obtaining a capability URL, given a capability name
+class LLCapabilityProvider
+{
+public:
+    virtual ~LLCapabilityProvider() {}
+    /**
+     * Get a capability URL, given a capability name. Returns empty string if
+     * no such capability is defined on this provider.
+     */
+    virtual std::string getCapability(const std::string& name) const = 0;
+    /**
+     * Get host to which to send that capability request.
+     */
+    virtual LLHost getHost() const = 0;
+    /**
+     * Describe this LLCapabilityProvider for logging etc.
+     */
+    virtual std::string getDescription() const = 0;
+};
+
+#endif /* ! defined(LL_LLCAPABILITYPROVIDER_H) */
diff --git a/indra/newview/llfloatergroups.cpp b/indra/newview/llfloatergroups.cpp
index 011774fa5e..65035d9b5c 100644
--- a/indra/newview/llfloatergroups.cpp
+++ b/indra/newview/llfloatergroups.cpp
@@ -59,6 +59,8 @@
 #include "llimview.h"
 #include "lltrans.h"
 
+using namespace LLOldEvents;
+
 // static
 std::map<const LLUUID, LLFloaterGroupPicker*> LLFloaterGroupPicker::sInstances;
 
diff --git a/indra/newview/llfloatergroups.h b/indra/newview/llfloatergroups.h
index b30d40581f..d3fb405b42 100644
--- a/indra/newview/llfloatergroups.h
+++ b/indra/newview/llfloatergroups.h
@@ -48,7 +48,7 @@
 #include "llfloater.h"
 #include <map>
 #include <boost/function.hpp>
-#include <boost/signal.hpp>
+#include <boost/signals2.hpp>
 
 class LLUICtrl;
 class LLTextBox;
@@ -63,7 +63,7 @@ public:
 	~LLFloaterGroupPicker();
 	
 	// Note: Don't return connection; use boost::bind + boost::signal::trackable to disconnect slots
-	typedef boost::signal<void (LLUUID id)> signal_t;	
+	typedef boost::signals2::signal<void (LLUUID id)> signal_t;	
 	void setSelectGroupCallback(const signal_t::slot_type& cb) { mGroupSelectSignal.connect(cb); }
 	void setPowersMask(U64 powers_mask);
 	BOOL postBuild();
@@ -87,14 +87,14 @@ protected:
 	static instance_map_t sInstances;
 };
 
-class LLPanelGroups : public LLPanel, public LLSimpleListener
+class LLPanelGroups : public LLPanel, public LLOldEvents::LLSimpleListener
 {
 public:
 	LLPanelGroups();
 	virtual ~LLPanelGroups();
 
 	//LLEventListener
-	/*virtual*/ bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata);
+	/*virtual*/ bool handleEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata);
 	
 	// clear the group list, and get a fresh set of info.
 	void reset();
diff --git a/indra/newview/llfolderview.h b/indra/newview/llfolderview.h
index 1b128d84ee..d8eb9008f0 100644
--- a/indra/newview/llfolderview.h
+++ b/indra/newview/llfolderview.h
@@ -763,7 +763,7 @@ public:
 	void setFilterPermMask(PermissionMask filter_perm_mask) { mFilter.setFilterPermissions(filter_perm_mask); }
 	void setAllowMultiSelect(BOOL allow) { mAllowMultiSelect = allow; }
 	
-	typedef boost::signal<void (const std::deque<LLFolderViewItem*>& items, BOOL user_action)> signal_t;	
+	typedef boost::signals2::signal<void (const std::deque<LLFolderViewItem*>& items, BOOL user_action)> signal_t;	
 	void setSelectCallback(const signal_t::slot_type& cb) { mSelectSignal.connect(cb); }
 	
 	LLInventoryFilter* getFilter() { return &mFilter; }
diff --git a/indra/newview/llinventorybridge.cpp b/indra/newview/llinventorybridge.cpp
index fe8d1c4844..89f9242b06 100644
--- a/indra/newview/llinventorybridge.cpp
+++ b/indra/newview/llinventorybridge.cpp
@@ -89,6 +89,8 @@
 #include "llfloateropenobject.h"
 #include "lltrans.h"
 
+using namespace LLOldEvents;
+
 // Helpers
 // bug in busy count inc/dec right now, logic is complex... do we really need it?
 void inc_busy_count()
diff --git a/indra/newview/llnetmap.cpp b/indra/newview/llnetmap.cpp
index 7d18616a13..53c7484e72 100644
--- a/indra/newview/llnetmap.cpp
+++ b/indra/newview/llnetmap.cpp
@@ -58,6 +58,8 @@
 
 static LLRegisterWidget<LLNetMap> r1("net_map");
 
+using namespace LLOldEvents;
+
 const F32 MAP_SCALE_MIN = 64;
 const F32 MAP_SCALE_MID = 172;
 const F32 MAP_SCALE_MAX = 512;
diff --git a/indra/newview/llteleporthistory.h b/indra/newview/llteleporthistory.h
index 631857d7c8..fc061075c9 100644
--- a/indra/newview/llteleporthistory.h
+++ b/indra/newview/llteleporthistory.h
@@ -38,7 +38,7 @@
 #include <vector>
 #include <string>
 #include <boost/function.hpp>
-#include <boost/signals/connection.hpp>
+#include <boost/signals2/connection.hpp>
 
 
 /**
@@ -206,7 +206,7 @@ private:
 	 * Using this connection we get notified when a teleport finishes
 	 * or initial location update occurs.
 	 */
-	boost::signals::connection	mTeleportFinishedConn;
+	boost::signals2::connection	mTeleportFinishedConn;
 };
 
 #endif
diff --git a/indra/newview/lltoolpipette.h b/indra/newview/lltoolpipette.h
index fcccafe1a4..533e8a7c95 100644
--- a/indra/newview/lltoolpipette.h
+++ b/indra/newview/lltoolpipette.h
@@ -41,7 +41,7 @@
 #include "lltool.h"
 #include "lltextureentry.h"
 #include <boost/function.hpp>
-#include <boost/signal.hpp>
+#include <boost/signals2.hpp>
 
 class LLViewerObject;
 class LLPickInfo;
@@ -59,7 +59,7 @@ public:
 	virtual BOOL	handleToolTip(S32 x, S32 y, std::string& msg, LLRect *sticky_rect_screen);
 
 	// Note: Don't return connection; use boost::bind + boost::signal::trackable to disconnect slots
-	typedef boost::signal<void (const LLTextureEntry& te)> signal_t;
+	typedef boost::signals2::signal<void (const LLTextureEntry& te)> signal_t;
 	void setToolSelectCallback(const signal_t::slot_type& cb) { mSignal.connect(cb); }
 	void setResult(BOOL success, const std::string& msg);
 	
diff --git a/indra/newview/llviewerinventory.cpp b/indra/newview/llviewerinventory.cpp
index 52c49dd05d..b1482d5ce4 100644
--- a/indra/newview/llviewerinventory.cpp
+++ b/indra/newview/llviewerinventory.cpp
@@ -762,56 +762,39 @@ void move_inventory_item(
 	gAgent.sendReliableMessage();
 }
 
-class LLCopyInventoryFromNotecardResponder : public LLHTTPClient::Responder
-{
-public:
-	//If we get back a normal response, handle it here
-	virtual void result(const LLSD& content)
-	{
-		// What do we do here?
-		llinfos << "CopyInventoryFromNotecard request successful." << llendl;
-	}
-
-	//If we get back an error (not found, etc...), handle it here
-	virtual void error(U32 status, const std::string& reason)
-	{
-		llinfos << "LLCopyInventoryFromNotecardResponder::error "
-			<< status << ": " << reason << llendl;
-	}
-};
-
 void copy_inventory_from_notecard(const LLUUID& object_id, const LLUUID& notecard_inv_id, const LLInventoryItem *src, U32 callback_id)
 {
-	LLSD body;
 	LLViewerRegion* viewer_region = NULL;
-	if(object_id.notNull())
-	{
-		LLViewerObject* vo = gObjectList.findObject(object_id);
-		if(vo)
-		{
-			viewer_region = vo->getRegion();
-		}
+    LLViewerObject* vo = NULL;
+	if (object_id.notNull() && (vo = gObjectList.findObject(object_id)) != NULL)
+    {
+        viewer_region = vo->getRegion();
 	}
 
 	// Fallback to the agents region if for some reason the 
 	// object isn't found in the viewer.
-	if(!viewer_region)
+	if (! viewer_region)
 	{
 		viewer_region = gAgent.getRegion();
 	}
 
-	if(viewer_region)
+	if (! viewer_region)
 	{
-		std::string url = viewer_region->getCapability("CopyInventoryFromNotecard");
-		if (!url.empty())
-		{
-			body["notecard-id"] = notecard_inv_id;
-			body["object-id"] = object_id;
-			body["item-id"] = src->getUUID();
-			body["folder-id"] = gInventory.findCategoryUUIDForType(src->getType());
-			body["callback-id"] = (LLSD::Integer)callback_id;
-
-			LLHTTPClient::post(url, body, new LLCopyInventoryFromNotecardResponder());
-		}
-	}
+        LL_WARNS("copy_inventory_from_notecard") << "Can't find region from object_id "
+                                                 << object_id << " or gAgent"
+                                                 << LL_ENDL;
+        return;
+    }
+
+    LLSD request, body;
+    body["notecard-id"] = notecard_inv_id;
+    body["object-id"] = object_id;
+    body["item-id"] = src->getUUID();
+    body["folder-id"] = gInventory.findCategoryUUIDForType(src->getType());
+    body["callback-id"] = (LLSD::Integer)callback_id;
+
+    request["message"] = "CopyInventoryFromNotecard";
+    request["payload"] = body;
+
+    viewer_region->getCapAPI().post(request);
 }
diff --git a/indra/newview/llviewermedia.cpp b/indra/newview/llviewermedia.cpp
index c2724b7cdd..1b3fd5d49b 100644
--- a/indra/newview/llviewermedia.cpp
+++ b/indra/newview/llviewermedia.cpp
@@ -46,7 +46,7 @@
 #include "lluuid.h"
 
 #include <boost/bind.hpp>	// for SkinFolder listener
-#include <boost/signal.hpp>
+#include <boost/signals2.hpp>
 
 
 // Implementation functions not exported into header file
diff --git a/indra/newview/llviewermenu.cpp b/indra/newview/llviewermenu.cpp
index 0abdaff4b6..f70e5ad242 100644
--- a/indra/newview/llviewermenu.cpp
+++ b/indra/newview/llviewermenu.cpp
@@ -1,4 +1,4 @@
- /** 
+/** 
  * @file llviewermenu.cpp
  * @brief Builds menus out of items.
  *
@@ -210,6 +210,7 @@
 #include "lltexlayer.h"
 
 using namespace LLVOAvatarDefines;
+using namespace LLOldEvents;
 
 BOOL enable_land_build(void*);
 BOOL enable_object_build(void*);
diff --git a/indra/newview/llviewermenufile.cpp b/indra/newview/llviewermenufile.cpp
index 97b121d71d..1352f2c72f 100644
--- a/indra/newview/llviewermenufile.cpp
+++ b/indra/newview/llviewermenufile.cpp
@@ -71,6 +71,8 @@
 // system libraries
 #include <boost/tokenizer.hpp>
 
+using namespace LLOldEvents;
+
 class LLFileEnableSaveAs : public view_listener_t
 {
 	bool handleEvent(const LLSD& userdata)
diff --git a/indra/newview/llviewerparcelmgr.cpp b/indra/newview/llviewerparcelmgr.cpp
index 20723ec360..da9587a359 100644
--- a/indra/newview/llviewerparcelmgr.cpp
+++ b/indra/newview/llviewerparcelmgr.cpp
@@ -2392,12 +2392,12 @@ LLViewerImage* LLViewerParcelMgr::getPassImage() const
 	return sPassImage;
 }
 
-boost::signals::connection LLViewerParcelMgr::setAgentParcelChangedCallback(parcel_changed_callback_t cb)
+boost::signals2::connection LLViewerParcelMgr::setAgentParcelChangedCallback(parcel_changed_callback_t cb)
 {
 	return mAgentParcelChangedSignal.connect(cb);
 }
 
-boost::signals::connection LLViewerParcelMgr::setTeleportFinishedCallback(parcel_changed_callback_t cb)
+boost::signals2::connection LLViewerParcelMgr::setTeleportFinishedCallback(parcel_changed_callback_t cb)
 {
 	return mTeleportFinishedSignal.connect(cb);
 }
diff --git a/indra/newview/llviewerparcelmgr.h b/indra/newview/llviewerparcelmgr.h
index 2f3583e33b..3426fda636 100644
--- a/indra/newview/llviewerparcelmgr.h
+++ b/indra/newview/llviewerparcelmgr.h
@@ -41,8 +41,8 @@
 #include "llui.h"
 
 #include <boost/function.hpp>
-#include <boost/signal.hpp>
-#include <boost/signals/connection.hpp>
+#include <boost/signals2.hpp>
+#include <boost/signals2/connection.hpp>
 
 class LLUUID;
 class LLMessageSystem;
@@ -83,8 +83,8 @@ class LLViewerParcelMgr : public LLSingleton<LLViewerParcelMgr>
 {
 
 public:
-	typedef boost::function<void()> parcel_changed_callback_t;
-	typedef boost::signal  <void()> parcel_changed_signal_t;
+	typedef boost::function        <void()> parcel_changed_callback_t;
+	typedef boost::signals2::signal<void()> parcel_changed_signal_t;
 
 	LLViewerParcelMgr();
 	~LLViewerParcelMgr();
@@ -263,8 +263,8 @@ public:
 	// the agent is banned or not in the allowed group
 	BOOL isCollisionBanned();
 
-	boost::signals::connection setAgentParcelChangedCallback(parcel_changed_callback_t cb);
-	boost::signals::connection setTeleportFinishedCallback(parcel_changed_callback_t cb);
+	boost::signals2::connection setAgentParcelChangedCallback(parcel_changed_callback_t cb);
+	boost::signals2::connection setTeleportFinishedCallback(parcel_changed_callback_t cb);
 	void onTeleportFinished();
 
 	static BOOL isParcelOwnedByAgent(const LLParcel* parcelp, U64 group_proxy_power);
diff --git a/indra/newview/llviewerregion.cpp b/indra/newview/llviewerregion.cpp
index 47619919b3..89ebe0cec8 100644
--- a/indra/newview/llviewerregion.cpp
+++ b/indra/newview/llviewerregion.cpp
@@ -66,6 +66,11 @@
 #include "llvoclouds.h"
 #include "llworld.h"
 #include "llspatialpartition.h"
+#include "stringize.h"
+
+#ifdef LL_WINDOWS
+	#pragma warning(disable:4355)
+#endif
 
 // Viewer object cache version, change if object update
 // format changes. JC
@@ -173,7 +178,18 @@ LLViewerRegion::LLViewerRegion(const U64 &handle,
 	mCacheEntriesCount(0),
 	mCacheID(),
 	mEventPoll(NULL),
-	mReleaseNotesRequested(FALSE)
+	mReleaseNotesRequested(FALSE),
+    // I'd prefer to set the LLCapabilityListener name to match the region
+    // name -- it's disappointing that's not available at construction time.
+    // We could instead store an LLCapabilityListener*, making
+    // setRegionNameAndZone() replace the instance. Would that pose
+    // consistency problems? Can we even request a capability before calling
+    // setRegionNameAndZone()?
+    // For testability -- the new Michael Feathers paradigm --
+    // LLCapabilityListener binds all the globals it expects to need at
+    // construction time.
+    mCapabilityListener(host.getString(), gMessageSystem, *this,
+                        gAgent.getID(), gAgent.getSessionID())
 {
 	mWidth = region_width_meters;
 	mOriginGlobal = from_region_handle(handle); 
@@ -224,7 +240,6 @@ LLViewerRegion::LLViewerRegion(const U64 &handle,
 	mObjectPartition.push_back(new LLBridgePartition());	//PARTITION_BRIDGE
 	mObjectPartition.push_back(new LLHUDParticlePartition());//PARTITION_HUD_PARTICLE
 	mObjectPartition.push_back(NULL);						//PARTITION_NONE
-	
 }
 
 
@@ -770,6 +785,15 @@ std::ostream& operator<<(std::ostream &s, const LLViewerRegion &region)
 	s << "{ ";
 	s << region.mHost;
 	s << " mOriginGlobal = " << region.getOriginGlobal()<< "\n";
+    std::string name(region.getName()), zone(region.getZoning());
+    if (! name.empty())
+    {
+        s << " mName         = " << name << '\n';
+    }
+    if (! zone.empty())
+    {
+        s << " mZoning       = " << zone << '\n';
+    }
 	s << "}";
 	return s;
 }
@@ -1514,3 +1538,8 @@ void LLViewerRegion::showReleaseNotes()
 	LLWeb::loadURL(url);
 	mReleaseNotesRequested = FALSE;
 }
+
+std::string LLViewerRegion::getDescription() const
+{
+    return stringize(*this);
+}
diff --git a/indra/newview/llviewerregion.h b/indra/newview/llviewerregion.h
index f43167f93a..35f374a4c8 100644
--- a/indra/newview/llviewerregion.h
+++ b/indra/newview/llviewerregion.h
@@ -49,6 +49,8 @@
 #include "lldatapacker.h"
 #include "llvocache.h"
 #include "llweb.h"
+#include "llcapabilityprovider.h"
+#include "llcapabilitylistener.h"
 
 // Surface id's
 #define LAND  1
@@ -66,8 +68,9 @@ class LLSurface;
 class LLVOCache;
 class LLVOCacheEntry;
 class LLSpatialPartition;
+class LLEventPump;
 
-class LLViewerRegion 
+class LLViewerRegion: public LLCapabilityProvider // implements this interface
 {
 public:
 	//MUST MATCH THE ORDER OF DECLARATION IN CONSTRUCTOR
@@ -226,11 +229,19 @@ public:
 	// Get/set named capability URLs for this region.
 	void setSeedCapability(const std::string& url);
 	void setCapability(const std::string& name, const std::string& url);
-	std::string getCapability(const std::string& name) const;
+	// implements LLCapabilityProvider
+    virtual std::string getCapability(const std::string& name) const;
 	static bool isSpecialCapabilityName(const std::string &name);
 	void logActiveCapabilities() const;
 
-	const LLHost	&getHost() const			{ return mHost; }
+    /// Capability-request exception
+    typedef LLCapabilityListener::ArgError ArgError;
+    /// Get LLEventPump on which we listen for capability requests
+    /// (https://wiki.lindenlab.com/wiki/Viewer:Messaging/Messaging_Notes#Capabilities)
+    LLEventPump& getCapAPI() { return mCapabilityListener.getCapAPI(); }
+
+    /// implements LLCapabilityProvider
+	virtual LLHost	getHost() const				{ return mHost; }
 	const U64 		&getHandle() const 			{ return mHandle; }
 
 	LLSurface		&getLand() const			{ return *mLandp; }
@@ -274,6 +285,8 @@ public:
 	void calculateCameraDistance();
 
 	friend std::ostream& operator<<(std::ostream &s, const LLViewerRegion &region);
+    /// implements LLCapabilityProvider
+    virtual std::string getDescription() const;
 
 	LLSpatialPartition* getSpatialPartition(U32 type);
 public:
@@ -391,6 +404,11 @@ private:
 	
 	LLEventPoll* mEventPoll;
 
+    /// Post an event to this LLCapabilityListener to invoke a capability message on
+    /// this LLViewerRegion's server
+    /// (https://wiki.lindenlab.com/wiki/Viewer:Messaging/Messaging_Notes#Capabilities)
+    LLCapabilityListener mCapabilityListener;
+
 private:
 	bool	mAlive;					// can become false if circuit disconnects
 
@@ -458,5 +476,3 @@ inline BOOL LLViewerRegion::getReleaseNotesRequested() const
 }
 
 #endif
-
-
diff --git a/indra/newview/llviewerthrottle.cpp b/indra/newview/llviewerthrottle.cpp
index bf779c427a..73065c5c00 100644
--- a/indra/newview/llviewerthrottle.cpp
+++ b/indra/newview/llviewerthrottle.cpp
@@ -40,6 +40,8 @@
 #include "llviewerstats.h"
 #include "lldatapacker.h"
 
+using namespace LLOldEvents;
+
 // consts
 
 // The viewer is allowed to set the under-the-hood bandwidth to 50%
diff --git a/indra/newview/tests/llcapabilitylistener_test.cpp b/indra/newview/tests/llcapabilitylistener_test.cpp
new file mode 100644
index 0000000000..3c5f6fad2d
--- /dev/null
+++ b/indra/newview/tests/llcapabilitylistener_test.cpp
@@ -0,0 +1,274 @@
+/**
+ * @file   llcapabilitylistener_test.cpp
+ * @author Nat Goodspeed
+ * @date   2008-12-31
+ * @brief  Test for llcapabilitylistener.cpp.
+ * 
+ * $LicenseInfo:firstyear=2008&license=internal$
+ * Copyright (c) 2008, Linden Research, Inc.
+ * $/LicenseInfo$
+ */
+
+// Precompiled header
+#include "../llviewerprecompiledheaders.h"
+// Own header
+#include "../llcapabilitylistener.h"
+// STL headers
+#include <stdexcept>
+#include <map>
+#include <vector>
+// std headers
+// external library headers
+#include "boost/bind.hpp"
+// other Linden headers
+#include "../test/lltut.h"
+#include "../llcapabilityprovider.h"
+#include "lluuid.h"
+#include "llerrorcontrol.h"
+#include "tests/networkio.h"
+#include "tests/commtest.h"
+#include "stringize.h"
+
+#if defined(LL_WINDOWS)
+#pragma warning(disable: 4355)      // using 'this' in base-class ctor initializer expr
+#endif
+
+/*****************************************************************************
+*   TestCapabilityProvider
+*****************************************************************************/
+struct TestCapabilityProvider: public LLCapabilityProvider
+{
+    TestCapabilityProvider(const LLHost& host):
+        mHost(host)
+    {}
+
+    std::string getCapability(const std::string& cap) const
+    {
+        CapMap::const_iterator found = mCaps.find(cap);
+        if (found != mCaps.end())
+            return found->second;
+        // normal LLViewerRegion lookup failure mode
+        return "";
+    }
+    void setCapability(const std::string& cap, const std::string& url)
+    {
+        mCaps[cap] = url;
+    }
+    LLHost getHost() const { return mHost; }
+    std::string getDescription() const { return "TestCapabilityProvider"; }
+
+    LLHost mHost;
+    typedef std::map<std::string, std::string> CapMap;
+    CapMap mCaps;
+};
+
+/*****************************************************************************
+*   Dummy LLMessageSystem methods
+*****************************************************************************/
+/*==========================================================================*|
+// This doesn't work because we're already linking in llmessage.a, and we get
+// duplicate-symbol errors from the linker. Perhaps if I wanted to go through
+// the exercise of providing dummy versions of every single symbol defined in
+// message.o -- maybe some day.
+typedef std::vector< std::pair<std::string, std::string> > StringPairVector;
+StringPairVector call_history;
+
+S32 LLMessageSystem::sendReliable(const LLHost& host)
+{
+    call_history.push_back(StringPairVector::value_type("sendReliable", stringize(host)));
+    return 0;
+}
+|*==========================================================================*/
+
+/*****************************************************************************
+*   TUT
+*****************************************************************************/
+namespace tut
+{
+    struct llcapears_data: public commtest_data
+    {
+        TestCapabilityProvider provider;
+        LLCapabilityListener regionListener;
+        LLEventPump& regionPump;
+
+        llcapears_data():
+            provider(host),
+            regionListener("testCapabilityListener", NULL, provider, LLUUID(), LLUUID()),
+            regionPump(regionListener.getCapAPI())
+        {
+            provider.setCapability("good", server + "capability-test");
+            provider.setCapability("fail", server + "fail");
+        }
+    };
+    typedef test_group<llcapears_data> llcapears_group;
+    typedef llcapears_group::object llcapears_object;
+    llcapears_group llsdmgr("llcapabilitylistener");
+
+    struct CaptureError: public LLError::OverrideFatalFunction
+    {
+        CaptureError():
+            LLError::OverrideFatalFunction(boost::bind(&CaptureError::operator(), this, _1))
+        {
+            LLError::setPrintLocation(false);
+        }
+
+        struct FatalException: public std::runtime_error
+        {
+            FatalException(const std::string& what): std::runtime_error(what) {}
+        };
+
+        void operator()(const std::string& message)
+        {
+            error = message;
+            throw FatalException(message);
+        }
+
+        std::string error;
+    };
+
+    template<> template<>
+    void llcapears_object::test<1>()
+    {
+        LLSD request, body;
+        body["data"] = "yes";
+        request["payload"] = body;
+        request["reply"] = replyPump.getName();
+        request["error"] = errorPump.getName();
+        std::string threw;
+        try
+        {
+            CaptureError capture;
+            regionPump.post(request);
+        }
+        catch (const CaptureError::FatalException& e)
+        {
+            threw = e.what();
+        }
+        ensure_contains("missing capability name", threw, "without 'message' key");
+    }
+
+    template<> template<>
+    void llcapears_object::test<2>()
+    {
+        LLSD request, body;
+        body["data"] = "yes";
+        request["message"] = "good";
+        request["payload"] = body;
+        request["reply"] = replyPump.getName();
+        request["error"] = errorPump.getName();
+        regionPump.post(request);
+        ensure("got response", netio.pump());
+        ensure("success response", success);
+        ensure_equals(result.asString(), "success");
+
+        body["status"] = 499;
+        body["reason"] = "custom error message";
+        request["message"] = "fail";
+        request["payload"] = body;
+        regionPump.post(request);
+        ensure("got response", netio.pump());
+        ensure("failure response", ! success);
+        ensure_equals(result["status"].asInteger(), body["status"].asInteger());
+        ensure_equals(result["reason"].asString(),  body["reason"].asString());
+    }
+
+    template<> template<>
+    void llcapears_object::test<3>()
+    {
+        LLSD request, body;
+        body["data"] = "yes";
+        request["message"] = "unknown";
+        request["payload"] = body;
+        request["reply"] = replyPump.getName();
+        request["error"] = errorPump.getName();
+        std::string threw;
+        try
+        {
+            CaptureError capture;
+            regionPump.post(request);
+        }
+        catch (const CaptureError::FatalException& e)
+        {
+            threw = e.what();
+        }
+        ensure_contains("bad capability name", threw, "unsupported capability");
+    }
+
+    struct TestMapper: public LLCapabilityListener::CapabilityMapper
+    {
+        // Instantiator gets to specify whether mapper expects a reply.
+        // I'd really like to be able to test CapabilityMapper::buildMessage()
+        // functionality, too, but -- even though LLCapabilityListener accepts
+        // the LLMessageSystem* that it passes to CapabilityMapper --
+        // LLMessageSystem::sendReliable(const LLHost&) isn't virtual, so it's
+        // not helpful to pass a subclass instance. I suspect that making any
+        // LLMessageSystem methods virtual would provoke howls of outrage,
+        // given how heavily it's used. Nor can I just provide a local
+        // definition of LLMessageSystem::sendReliable(const LLHost&) because
+        // we're already linking in the rest of message.o via llmessage.a, and
+        // that produces duplicate-symbol link errors.
+        TestMapper(const std::string& replyMessage = std::string()):
+            LLCapabilityListener::CapabilityMapper("test", replyMessage)
+        {}
+        virtual void buildMessage(LLMessageSystem* msg,
+                                  const LLUUID& agentID,
+                                  const LLUUID& sessionID,
+                                  const std::string& capabilityName,
+                                  const LLSD& payload) const
+        {
+            msg->newMessageFast(_PREHASH_SetStartLocationRequest);
+            msg->nextBlockFast( _PREHASH_AgentData);
+            msg->addUUIDFast(_PREHASH_AgentID, agentID);
+            msg->addUUIDFast(_PREHASH_SessionID, sessionID);
+            msg->nextBlockFast( _PREHASH_StartLocationData);
+            // corrected by sim
+            msg->addStringFast(_PREHASH_SimName, "");
+            msg->addU32Fast(_PREHASH_LocationID, payload["HomeLocation"]["LocationId"].asInteger());
+/*==========================================================================*|
+            msg->addVector3Fast(_PREHASH_LocationPos,
+                                ll_vector3_from_sdmap(payload["HomeLocation"]["LocationPos"]));
+            msg->addVector3Fast(_PREHASH_LocationLookAt,
+                                ll_vector3_from_sdmap(payload["HomeLocation"]["LocationLookAt"]));
+|*==========================================================================*/
+        }
+    };
+
+    template<> template<>
+    void llcapears_object::test<4>()
+    {
+        TestMapper testMapper("WantReply");
+        LLSD request, body;
+        body["data"] = "yes";
+        request["message"] = "test";
+        request["payload"] = body;
+        request["reply"] = replyPump.getName();
+        request["error"] = errorPump.getName();
+        std::string threw;
+        try
+        {
+            CaptureError capture;
+            regionPump.post(request);
+        }
+        catch (const CaptureError::FatalException& e)
+        {
+            threw = e.what();
+        }
+        ensure_contains("capability mapper wants reply", threw, "unimplemented support for reply message");
+    }
+
+    template<> template<>
+    void llcapears_object::test<5>()
+    {
+        TestMapper testMapper;
+        std::string threw;
+        try
+        {
+            TestMapper testMapper2;
+        }
+        catch (const std::runtime_error& e)
+        {
+            threw = e.what();
+        }
+        ensure_contains("no dup cap mapper", threw, "DupCapMapper");
+    }
+}