CHUI-580 : Fixed : Clean up the use of display name. Allow the use of the legacy protocol in settings.xml

3 files changed, 75 insertions, 129 deletions

diff --git a/indra/llmessage/llavatarnamecache.cpp b/indra/llmessage/llavatarnamecache.cpp
index 329871d8eb..15c4f2a207 100644
--- a/indra/llmessage/llavatarnamecache.cpp
+++ b/indra/llmessage/llavatarnamecache.cpp
@@ -47,18 +47,22 @@ namespace LLAvatarNameCache
 	// current region supports display names.
 	bool sRunning = false;
 	
+	// Use the People API (modern) for fetching name if true. Use the old legacy protocol if false.
+	// For testing, there's a UsePeopleAPI setting that can be flipped (must restart viewer).
+	bool sUsePeopleAPI = true;
+	
 	// 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
+	// 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
+	// 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;
 
@@ -69,21 +73,21 @@ namespace LLAvatarNameCache
 	typedef std::map<LLUUID, callback_signal_t*> signal_map_t;
 	signal_map_t sSignalMap;
 
-	// names we know about
+	// The cache at last, i.e. avatar 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
+	// Send bulk lookup requests a few times a second at most.
+	// Only need per-frame timing resolution.
 	LLFrameTimer sRequestTimer;
 
-    /// Maximum time an unrefreshed cache entry is allowed
+    // Maximum time an unrefreshed cache entry is allowed.
     const F64 MAX_UNREFRESHED_TIME = 20.0 * 60.0;
 
-    /// Time when unrefreshed cached names were checked last
+    // Time when unrefreshed cached names were checked last.
     static F64 sLastExpireCheck;
 
-	/// Time-to-live for a temp cache entry.
+	// Time-to-live for a temp cache entry.
 	const F64 TEMP_CACHE_ENTRY_LIFETIME = 60.0;
 
 	//-----------------------------------------------------------------------
@@ -91,26 +95,18 @@ namespace LLAvatarNameCache
 	//-----------------------------------------------------------------------
 
 	// 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);
+					 const LLAvatarName& av_name);
 
 	void requestNamesViaCapability();
 
 	// Legacy name system callback
 	void legacyNameCallback(const LLUUID& agent_id,
 							const std::string& full_name,
-							bool is_group
-							);
+							bool is_group);
 
 	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,
@@ -209,7 +205,7 @@ public:
 			av_name.dump();
 			
 			// cache it and fire signals
-			LLAvatarNameCache::processName(agent_id, av_name, true);
+			LLAvatarNameCache::processName(agent_id, av_name);
 		}
 
 		// Same logic as error response case
@@ -271,7 +267,7 @@ void LLAvatarNameCache::handleAgentError(const LLUUID& agent_id)
     }
 	else
     {
-        // we have a chached (but probably expired) entry - since that would have
+        // we have a cached (but probably expired) entry - since that would have
         // been returned by the get method, there is no need to signal anyone
 
         // Clear this agent from the pending list
@@ -281,22 +277,20 @@ void LLAvatarNameCache::handleAgentError(const LLUUID& agent_id)
         LL_DEBUGS("AvNameCache") << "LLAvatarNameCache use cache for agent " << agent_id << LL_ENDL;
 		av_name.dump();
 
-		av_name.mExpires = LLFrameTimer::getTotalSeconds() + TEMP_CACHE_ENTRY_LIFETIME; // reset expiry time so we don't constantly rerequest.
+		 // Reset expiry time so we don't constantly rerequest.
+		av_name.setExpires(TEMP_CACHE_ENTRY_LIFETIME);
     }
 }
 
-void LLAvatarNameCache::processName(const LLUUID& agent_id,
-									const LLAvatarName& av_name,
-									bool add_to_cache)
+void LLAvatarNameCache::processName(const LLUUID& agent_id, const LLAvatarName& av_name)
 {
-	if (add_to_cache)
-	{
-		sCache[agent_id] = av_name;
-	}
+	// Add to the cache
+	sCache[agent_id] = av_name;
 
+	// Suppress request from the queue
 	sPendingQueue.erase(agent_id);
 
-	// signal everyone waiting on this name
+	// Signal everyone waiting on this name
 	signal_map_t::iterator sig_it =	sSignalMap.find(agent_id);
 	if (sig_it != sSignalMap.end())
 	{
@@ -373,22 +367,20 @@ void LLAvatarNameCache::legacyNameCallback(const LLUUID& agent_id,
 										   const std::string& full_name,
 										   bool is_group)
 {
-	// 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;
 	LL_DEBUGS("AvNameCache") << "LLAvatarNameCache::legacyNameCallback "
 							 << "agent " << agent_id << " "
 							 << "full name '" << full_name << "'"
 							 << ( is_group ? " [group]" : "" )
 							 << LL_ENDL;
-	buildLegacyName(full_name, &av_name);
+	
+	// Construct an av_name record from this name.
+	LLAvatarName av_name;
+	av_name.fromString(full_name);
+	av_name.dump();
 
 	// Add to cache, because if we don't we'll keep rerequesting the
-	// same record forever.  buildLegacyName should always guarantee
-	// that these records expire reasonably soon
-	// (in TEMP_CACHE_ENTRY_LIFETIME seconds), so if the failure was due
-	// to something temporary we will eventually request and get the right data.
-	processName(agent_id, av_name, true);
+	// same record forever.
+	processName(agent_id, av_name);
 }
 
 void LLAvatarNameCache::requestNamesViaLegacy()
@@ -410,18 +402,19 @@ void LLAvatarNameCache::requestNamesViaLegacy()
 		LL_DEBUGS("AvNameCache") << "LLAvatarNameCache::requestNamesViaLegacy agent " << agent_id << LL_ENDL;
 
 		gCacheName->get(agent_id, false,  // legacy compatibility
-			boost::bind(&LLAvatarNameCache::legacyNameCallback,
-				_1, _2, _3));
+			boost::bind(&LLAvatarNameCache::legacyNameCallback, _1, _2, _3));
 	}
 }
 
-void LLAvatarNameCache::initClass(bool running)
+void LLAvatarNameCache::initClass(bool running, bool usePeopleAPI)
 {
 	sRunning = running;
+	sUsePeopleAPI = usePeopleAPI;
 }
 
 void LLAvatarNameCache::cleanupClass()
 {
+	sCache.clear();
 }
 
 void LLAvatarNameCache::importFile(std::istream& istr)
@@ -481,6 +474,11 @@ bool LLAvatarNameCache::hasNameLookupURL()
 	return !sNameLookupURL.empty();
 }
 
+bool LLAvatarNameCache::usePeopleAPI()
+{
+	return hasNameLookupURL() && sUsePeopleAPI;
+}
+
 void LLAvatarNameCache::idle()
 {
 	// By convention, start running at first idle() call
@@ -497,13 +495,12 @@ void LLAvatarNameCache::idle()
 
 	if (!sAskQueue.empty())
 	{
-        if (hasNameLookupURL())
+        if (usePeopleAPI())
         {
             requestNamesViaCapability();
         }
         else
         {
-            // ...fall back to legacy name cache system
             requestNamesViaLegacy();
         }
 	}
@@ -563,18 +560,6 @@ void LLAvatarNameCache::eraseUnrefreshed()
 	}
 }
 
-void LLAvatarNameCache::buildLegacyName(const std::string& full_name,
-										LLAvatarName* av_name)
-{
-	llassert(av_name);
-	av_name->fromString(full_name,TEMP_CACHE_ENTRY_LIFETIME);
-	LL_DEBUGS("AvNameCache") << "LLAvatarNameCache::buildLegacyName "
-							 << full_name
-							 << LL_ENDL;
-	// DEBUG ONLY!!! DO NOT COMMIT!!!
-	av_name->dump();
-}
-
 // 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)
@@ -582,38 +567,24 @@ bool LLAvatarNameCache::get(const LLUUID& agent_id, LLAvatarName *av_name)
 	if (sRunning)
 	{
 		// ...only do immediate lookups when cache is running
-		if (hasNameLookupURL())
+		std::map<LLUUID,LLAvatarName>::iterator it = sCache.find(agent_id);
+		if (it != sCache.end())
 		{
-			// ...use display names cache
-			std::map<LLUUID,LLAvatarName>::iterator it = sCache.find(agent_id);
-			if (it != sCache.end())
-			{
-				*av_name = it->second;
+			*av_name = it->second;
 
-				// re-request name if entry is expired
-				if (av_name->mExpires < LLFrameTimer::getTotalSeconds())
+			// re-request name if entry is expired
+			if (av_name->mExpires < LLFrameTimer::getTotalSeconds())
+			{
+				if (!isRequestPending(agent_id))
 				{
-					if (!isRequestPending(agent_id))
-					{
-						LL_DEBUGS("AvNameCache") << "LLAvatarNameCache::get "
-												 << "refresh agent " << agent_id
-												 << LL_ENDL;
-						sAskQueue.insert(agent_id);
-					}
+					LL_DEBUGS("AvNameCache") << "LLAvatarNameCache::get "
+											 << "refresh agent " << agent_id
+											 << LL_ENDL;
+					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;
 			}
+				
+			return true;
 		}
 	}
 
@@ -644,30 +615,14 @@ LLAvatarNameCache::callback_connection_t LLAvatarNameCache::get(const LLUUID& ag
 	if (sRunning)
 	{
 		// ...only do immediate lookups when cache is running
-		if (hasNameLookupURL())
-		{
-			// ...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 connection;
-				}
-			}
-		}
-		else
+		std::map<LLUUID,LLAvatarName>::iterator it = sCache.find(agent_id);
+		if (it != sCache.end())
 		{
-			// ...use old name system
-			std::string full_name;
-			if (gCacheName->getFullName(agent_id, full_name))
+			const LLAvatarName& av_name = it->second;
+			
+			if (av_name.mExpires > LLFrameTimer::getTotalSeconds())
 			{
-				LLAvatarName av_name;
-				buildLegacyName(full_name, &av_name);
+				// ...name already exists in cache, fire callback now
 				fireSignal(agent_id, slot, av_name);
 				return connection;
 			}
@@ -709,11 +664,6 @@ void LLAvatarNameCache::setUseDisplayNames(bool use)
 	}
 }
 
-void LLAvatarNameCache::flushCache()
-{
-	sCache.clear();
-}
-
 void LLAvatarNameCache::erase(const LLUUID& agent_id)
 {
 	sCache.erase(agent_id);
diff --git a/indra/llmessage/llavatarnamecache.h b/indra/llmessage/llavatarnamecache.h
index e172601432..2a8eb46187 100644
--- a/indra/llmessage/llavatarnamecache.h
+++ b/indra/llmessage/llavatarnamecache.h
@@ -37,33 +37,33 @@ 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 initClass(bool running, bool usePeopleAPI);
 	void cleanupClass();
 
+	// Import/export the name cache to file.
 	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
+	// 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?
+	// Do we have a valid lookup URL, i.e. are we trying to use the
+	// more recent display name lookup system?
 	bool hasNameLookupURL();
+	bool usePeopleAPI();
 	
 	// Periodically makes a batch request for display names not already in
-	// cache.  Call once per frame.
+	// cache. Called once per frame.
 	void idle();
 
 	// If name is in cache, returns true and fills in provided LLAvatarName
-	// otherwise returns false
+	// otherwise returns false.
 	bool get(const LLUUID& agent_id, LLAvatarName *av_name);
 
 	// Callback types for get() below
@@ -73,23 +73,19 @@ namespace LLAvatarNameCache
 	typedef callback_signal_t::slot_type callback_slot_t;
 	typedef boost::signals2::connection callback_connection_t;
 
-	// Fetches name information and calls callback.
-	// If name information is in cache, callback will be called immediately.
+	// Fetches name information and calls callbacks.
+	// If name information is in cache, callbacks will be called immediately.
 	callback_connection_t get(const LLUUID& agent_id, callback_slot_t slot);
 
-	// Allow display names to be explicitly disabled for testing.
+	// Set display name: flips the switch and triggers the callbacks.
 	void setUseDisplayNames(bool use);
-	bool useDisplayNames();
-
-	void flushCache();
 	
+	void insert(const LLUUID& agent_id, const LLAvatarName& av_name);
 	void erase(const LLUUID& agent_id);
 
-    /// Provide some fallback for agents that return errors
+    /// Provide some fallback for agents that return errors.
 	void handleAgentError(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);
diff --git a/indra/llmessage/llcachename.h b/indra/llmessage/llcachename.h
index b108e37157..d238c3a247 100644
--- a/indra/llmessage/llcachename.h
+++ b/indra/llmessage/llcachename.h
@@ -40,7 +40,7 @@ typedef boost::signals2::signal<void (const LLUUID& id,
                                       bool is_group)> LLCacheNameSignal;
 typedef LLCacheNameSignal::slot_type LLCacheNameCallback;
 
-// Old callback with user data for compatability
+// Old callback with user data for compatibility
 typedef void (*old_callback_t)(const LLUUID&, const std::string&, bool, void*);
 
 // Here's the theory: