SL-12748 Blocked username displays old name after name change

4 files changed, 100 insertions, 5 deletions

diff --git a/indra/llmessage/llavatarnamecache.cpp b/indra/llmessage/llavatarnamecache.cpp
index 6a287f0cc5..6ada12962c 100644
--- a/indra/llmessage/llavatarnamecache.cpp
+++ b/indra/llmessage/llavatarnamecache.cpp
@@ -285,12 +285,27 @@ void LLAvatarNameCache::processName(const LLUUID& agent_id, const LLAvatarName&
 		return;
 	}
 
+    bool updated_account = true; // assume obsolete value for new arrivals by default
+
+    std::map<LLUUID, LLAvatarName>::iterator it = mCache.find(agent_id);
+    if (it != mCache.end()
+        && (*it).second.getAccountName() == av_name.getAccountName())
+    {
+        updated_account = false;
+    }
+
 	// Add to the cache
 	mCache[agent_id] = av_name;
 
 	// Suppress request from the queue
 	mPendingQueue.erase(agent_id);
 
+	// notify mute list about changes
+    if (updated_account && mAccountNameChangedCallback)
+    {
+        mAccountNameChangedCallback(agent_id, av_name);
+    }
+
 	// Signal everyone waiting on this name
 	signal_map_t::iterator sig_it =	mSignalMap.find(agent_id);
 	if (sig_it != mSignalMap.end())
@@ -303,6 +318,8 @@ void LLAvatarNameCache::processName(const LLUUID& agent_id, const LLAvatarName&
 		delete signal;
 		signal = NULL;
 	}
+
+
 }
 
 void LLAvatarNameCache::requestNamesViaCapability()
diff --git a/indra/llmessage/llavatarnamecache.h b/indra/llmessage/llavatarnamecache.h
index ba89d569f3..549d1703fa 100644
--- a/indra/llmessage/llavatarnamecache.h
+++ b/indra/llmessage/llavatarnamecache.h
@@ -42,6 +42,7 @@ class LLAvatarNameCache : public LLSingleton<LLAvatarNameCache>
 	~LLAvatarNameCache();
 public:
 	typedef boost::signals2::signal<void (void)> use_display_name_signal_t;
+	typedef boost::function<void (const LLUUID id, const LLAvatarName& av_name)> account_name_changed_callback_t;
 
 	// Import/export the name cache to file.
 	bool importFile(std::istream& istr);
@@ -103,6 +104,8 @@ public:
 
 	void addUseDisplayNamesCallback(const use_display_name_signal_t::slot_type& cb);
 
+    void setAccountNameChangedCallback(const account_name_changed_callback_t& cb) { mAccountNameChangedCallback = cb; }
+
 private:
     // Handle name response off network.
     void processName(const LLUUID& agent_id,
@@ -141,6 +144,7 @@ private:
 private:
 
     use_display_name_signal_t mUseDisplayNamesSignal;
+    account_name_changed_callback_t mAccountNameChangedCallback;
 
     // Cache starts in a paused state until we can determine if the
     // current region supports display names.
diff --git a/indra/newview/llmutelist.cpp b/indra/newview/llmutelist.cpp
index 64df449c26..8a10a38b37 100644
--- a/indra/newview/llmutelist.cpp
+++ b/indra/newview/llmutelist.cpp
@@ -169,6 +169,14 @@ LLMuteList::LLMuteList() :
 	gMessageSystem.callWhenReady(boost::bind(&LLMessageSystem::setHandlerFuncFast, _1,
 											 _PREHASH_UseCachedMuteList, processUseCachedMuteList,
 											 static_cast<void**>(NULL)));
+
+    // make sure mute list's instance gets initialized before we start any name requests
+    LLAvatarNameCache::getInstance()->setAccountNameChangedCallback([this](const LLUUID& id, const LLAvatarName& av_name)
+        {
+            // it would be better to just pass LLAvatarName instead of doing unnesssesary copies
+            // but this way is just more convinient
+            onAccountNameChanged(id, av_name.getUserName());
+        });
 }
 
 //-----------------------------------------------------------------------------
@@ -179,6 +187,11 @@ LLMuteList::~LLMuteList()
 
 }
 
+void LLMuteList::cleanupSingleton()
+{
+    LLAvatarNameCache::getInstance()->setAccountNameChangedCallback(NULL);
+}
+
 BOOL LLMuteList::isLinden(const std::string& name) const
 {
 	std::string username = boost::replace_all_copy(name, ".", " ");
@@ -232,8 +245,8 @@ BOOL LLMuteList::add(const LLMute& mute, U32 flags)
         LL_WARNS() << "Trying to self; ignored" << LL_ENDL;
 		return FALSE;
 	}
-	
-	S32 mute_list_limit = gSavedSettings.getS32("MuteListLimit");
+
+	static LLCachedControl<S32> mute_list_limit(gSavedSettings, "MuteListLimit", 1000);
 	if (getMutes().size() >= mute_list_limit)
 	{
 		LL_WARNS() << "Mute limit is reached; ignored" << LL_ENDL;
@@ -358,6 +371,10 @@ void LLMuteList::updateAdd(const LLMute& mute)
 	msg->addU32("MuteFlags", mute.mFlags);
 	gAgent.sendReliableMessage();
 
+    if (!mIsLoaded)
+    {
+        LL_WARNS() << "Added elements to non-initialized block list" << LL_ENDL;
+    }
 	mIsLoaded = TRUE; // why is this here? -MG
 }
 
@@ -412,7 +429,6 @@ BOOL LLMuteList::remove(const LLMute& mute, U32 flags)
 		
 		// Must be after erase.
 		notifyObserversDetailed(localmute);
-		setLoaded();  // why is this here? -MG
 	}
 	else
 	{
@@ -426,7 +442,6 @@ BOOL LLMuteList::remove(const LLMute& mute, U32 flags)
 			mLegacyMutes.erase(legacy_it);
 			// Must be after erase.
 			notifyObserversDetailed(mute);
-			setLoaded(); // why is this here? -MG
 		}
 	}
 	
@@ -584,6 +599,19 @@ BOOL LLMuteList::loadFromFile(const std::string& filename)
 	}
 	fclose(fp);
 	setLoaded();
+
+    // server does not maintain up-to date account names (not display names!)
+    // in this list, so it falls to viewer.
+    pending_names_t::iterator iter = mPendingAgentNameUpdates.begin();
+    pending_names_t::iterator end = mPendingAgentNameUpdates.end();
+    while (iter != end)
+    {
+        // this will send updates to server, make sure mIsLoaded is set
+        onAccountNameChanged(iter->first, iter->second);
+        iter++;
+    }
+    mPendingAgentNameUpdates.clear();
+
 	return TRUE;
 }
 
@@ -767,6 +795,48 @@ void LLMuteList::onFileMuteList(void** user_data, S32 error_code, LLExtStat ext_
 	delete local_filename_and_path;
 }
 
+void LLMuteList::onAccountNameChanged(const LLUUID& id, const std::string& username)
+{
+    if (mIsLoaded)
+    {
+        LLMute mute(id, username, LLMute::AGENT);
+        mute_set_t::iterator mute_it = mMutes.find(mute);
+        if (mute_it != mMutes.end()
+            && mute_it->mName != mute.mName
+            && mute_it->mType == LLMute::AGENT) // just in case, it is std::set, not map
+        {
+            // existing mute, but name changed, copy data
+            mute.mFlags = mute_it->mFlags;
+
+            // erase old variant
+            mMutes.erase(mute_it);
+
+            // (re)add the mute entry.
+            {
+                std::pair<mute_set_t::iterator, bool> result = mMutes.insert(mute);
+                if (result.second)
+                {
+                    LL_INFOS() << "Muting " << mute.mName << " id " << mute.mID << " flags " << mute.mFlags << LL_ENDL;
+                    updateAdd(mute);
+                    // Do not notify observers here, observers do not know or need to handle name changes
+                    // Example: block list considers notifyObserversDetailed as a selection update;
+                    // Various chat/voice statuses care only about id and flags
+                    // Since apropriate update time for account names is considered to be in 'hours' it is
+                    // fine not to update UI (will be fine after restart or couple other changes)
+
+                }
+            }
+        }
+    }
+    else
+    {
+        // Delay update until we load file
+        // Ex: Buddies list can arrive too early since we prerequest
+        // names from Buddies list before we load blocklist
+        mPendingAgentNameUpdates[id] = username;
+    }
+}
+
 void LLMuteList::addObserver(LLMuteListObserver* observer)
 {
 	mObservers.insert(observer);
diff --git a/indra/newview/llmutelist.h b/indra/newview/llmutelist.h
index f2fcf3dbb3..0d426fbd48 100644
--- a/indra/newview/llmutelist.h
+++ b/indra/newview/llmutelist.h
@@ -73,6 +73,7 @@ class LLMuteList : public LLSingleton<LLMuteList>
 {
 	LLSINGLETON(LLMuteList);
 	~LLMuteList();
+	/*virtual*/ void cleanupSingleton();
 public:
 	// reasons for auto-unmuting a resident
 	enum EAutoReason 
@@ -131,6 +132,7 @@ private:
 	static void processUseCachedMuteList(LLMessageSystem* msg, void**);
 
 	static void onFileMuteList(void** user_data, S32 code, LLExtStat ext_status);
+	void onAccountNameChanged(const LLUUID& id, const std::string& username);
 
 private:
 	struct compare_by_name
@@ -155,7 +157,9 @@ private:
 	};
 	typedef std::set<LLMute, compare_by_id> mute_set_t;
 	mute_set_t mMutes;
-	
+	typedef std::map<LLUUID, std::string> pending_names_t;
+	pending_names_t mPendingAgentNameUpdates;
+
 	typedef std::set<std::string> string_set_t;
 	string_set_t mLegacyMutes;