1 files changed, 205 insertions, 40 deletions

diff --git a/indra/newview/llappearancemgr.cpp b/indra/newview/llappearancemgr.cpp
index 3c93a9df7e..9115d7e5c2 100644
--- a/indra/newview/llappearancemgr.cpp
+++ b/indra/newview/llappearancemgr.cpp
@@ -40,6 +40,7 @@
 #include "llgesturemgr.h"
 #include "llinventorybridge.h"
 #include "llinventoryfunctions.h"
+#include "llinventorymodelbackgroundfetch.h"
 #include "llinventoryobserver.h"
 #include "llnotificationsutil.h"
 #include "lloutfitobserver.h"
@@ -585,6 +586,71 @@ LLUpdateAppearanceAndEditWearableOnDestroy::~LLUpdateAppearanceAndEditWearableOn
 	}
 }
 
+class LLBrokenLinkObserver : public LLInventoryObserver
+{
+public:
+    LLUUID mUUID;
+    bool mEnforceItemRestrictions;
+    bool mEnforceOrdering;
+    nullary_func_t mPostUpdateFunc;
+
+    LLBrokenLinkObserver(const LLUUID& uuid,
+                          bool enforce_item_restrictions ,
+                          bool enforce_ordering ,
+                          nullary_func_t post_update_func) :
+        mUUID(uuid),
+        mEnforceItemRestrictions(enforce_item_restrictions),
+        mEnforceOrdering(enforce_ordering),
+        mPostUpdateFunc(post_update_func)
+    {
+    }
+    /* virtual */ void changed(U32 mask);
+    void postProcess();
+};
+
+void LLBrokenLinkObserver::changed(U32 mask)
+{
+    if (mask & LLInventoryObserver::REBUILD)
+    {
+        // This observer should be executed after LLInventoryPanel::itemChanged(),
+        // but if it isn't, consider calling updateAppearanceFromCOF with a delay
+        const uuid_set_t& changed_item_ids = gInventory.getChangedIDs();
+        for (uuid_set_t::const_iterator it = changed_item_ids.begin(); it != changed_item_ids.end(); ++it)
+        {
+            const LLUUID& id = *it;
+            if (id == mUUID)
+            {
+                // Might not be processed yet and it is not a
+                // good idea to update appearane here, postpone.
+                doOnIdleOneTime([this]()
+                                {
+                                    postProcess();
+                                });
+
+                gInventory.removeObserver(this);
+                return;
+            }
+        }
+    }
+}
+
+void LLBrokenLinkObserver::postProcess()
+{
+    LLViewerInventoryItem* item = gInventory.getItem(mUUID);
+    llassert(item && !item->getIsBrokenLink()); // the whole point was to get a correct link
+    if (item && item->getIsBrokenLink())
+    {
+        LL_INFOS_ONCE("Avatar") << "Outfit link broken despite being regenerated" << LL_ENDL;
+        LL_DEBUGS("Avatar", "Inventory") << "Outfit link " << mUUID << " \"" << item->getName() << "\" is broken despite being regenerated" << LL_ENDL;
+    }
+
+    LLAppearanceMgr::instance().updateAppearanceFromCOF(
+        mEnforceItemRestrictions ,
+        mEnforceOrdering ,
+        mPostUpdateFunc);
+    delete this;
+}
+
 
 struct LLFoundData
 {
@@ -1701,12 +1767,18 @@ void LLAppearanceMgr::shallowCopyCategory(const LLUUID& src_id, const LLUUID& ds
 	{
 		parent_id = gInventory.getRootFolderID();
 	}
-	LLUUID subfolder_id = gInventory.createNewCategory( parent_id,
-														LLFolderType::FT_NONE,
-														src_cat->getName());
-	shallowCopyCategoryContents(src_id, subfolder_id, cb);
+	gInventory.createNewCategory(
+        parent_id,
+        LLFolderType::FT_NONE,
+        src_cat->getName(),
+        [src_id, cb](const LLUUID &new_id)
+    {
+        LLAppearanceMgr::getInstance()->shallowCopyCategoryContents(src_id, new_id, cb);
 
-	gInventory.notifyObservers();
+        gInventory.notifyObservers();
+    },
+        src_cat->getThumbnailUUID()
+    );
 }
 
 void LLAppearanceMgr::slamCategoryLinks(const LLUUID& src_id, const LLUUID& dst_id,
@@ -2409,6 +2481,39 @@ void LLAppearanceMgr::updateAppearanceFromCOF(bool enforce_item_restrictions,
 
 	LL_DEBUGS("Avatar") << self_av_string() << "starting" << LL_ENDL;
 
+    if (gInventory.hasPosiblyBrockenLinks())
+    {
+        // Inventory has either broken links or links that
+        // haven't loaded yet.
+        // Check if LLAppearanceMgr needs to wait.
+        LLUUID current_outfit_id = getCOF();
+        LLInventoryModel::item_array_t cof_items;
+        LLInventoryModel::cat_array_t cof_cats;
+        LLFindBrokenLinks is_brocken_link;
+        gInventory.collectDescendentsIf(current_outfit_id,
+            cof_cats,
+            cof_items,
+            LLInventoryModel::EXCLUDE_TRASH,
+            is_brocken_link);
+
+        if (cof_items.size() > 0)
+        {
+            // Some links haven't loaded yet, but fetch isn't complete so
+            // links are likely fine and we will have to wait for them to
+            // load
+            if (LLInventoryModelBackgroundFetch::getInstance()->folderFetchActive())
+            {
+
+                LLBrokenLinkObserver* observer = new LLBrokenLinkObserver(cof_items.front()->getUUID(),
+                                                                            enforce_item_restrictions,
+                                                                            enforce_ordering,
+                                                                            post_update_func);
+                gInventory.addObserver(observer);
+                return;
+            }
+        }
+    }
+
 	if (enforce_item_restrictions)
 	{
 		// The point here is just to call
@@ -2725,22 +2830,29 @@ void LLAppearanceMgr::wearCategoryFinal(LLUUID& cat_id, bool copy_items, bool ap
 		{
 			pid = gInventory.getRootFolderID();
 		}
-		
-		LLUUID new_cat_id = gInventory.createNewCategory(
+
+		gInventory.createNewCategory(
 			pid,
 			LLFolderType::FT_NONE,
-			name);
-
-		// Create a CopyMgr that will copy items, manage its own destruction
-		new LLCallAfterInventoryCopyMgr(
-			*items, new_cat_id, std::string("wear_inventory_category_callback"),
-			boost::bind(&LLAppearanceMgr::wearInventoryCategoryOnAvatar,
-						LLAppearanceMgr::getInstance(),
-						gInventory.getCategory(new_cat_id),
-						append));
-
-		// BAP fixes a lag in display of created dir.
-		gInventory.notifyObservers();
+            name,
+            [cat_id, append](const LLUUID& new_cat_id)
+        {
+            LLInventoryModel::cat_array_t* cats;
+            LLInventoryModel::item_array_t* items;
+            gInventory.getDirectDescendentsOf(cat_id, cats, items);
+            // Create a CopyMgr that will copy items, manage its own destruction
+            new LLCallAfterInventoryCopyMgr(
+                *items, new_cat_id, std::string("wear_inventory_category_callback"),
+                boost::bind(&LLAppearanceMgr::wearInventoryCategoryOnAvatar,
+                    LLAppearanceMgr::getInstance(),
+                    gInventory.getCategory(new_cat_id),
+                    append));
+
+            // BAP fixes a lag in display of created dir.
+            gInventory.notifyObservers();
+        },
+            cat->getThumbnailUUID()
+        );
 	}
 	else
 	{
@@ -3198,7 +3310,7 @@ void LLAppearanceMgr::copyLibraryGestures()
 
 	// Copy gestures
 	LLUUID lib_gesture_cat_id =
-		gInventory.findLibraryCategoryUUIDForType(LLFolderType::FT_GESTURE,false);
+		gInventory.findLibraryCategoryUUIDForType(LLFolderType::FT_GESTURE);
 	if (lib_gesture_cat_id.isNull())
 	{
 		LL_WARNS() << "Unable to copy gestures, source category not found" << LL_ENDL;
@@ -3981,26 +4093,15 @@ void LLAppearanceMgr::makeNewOutfitLinks(const std::string& new_folder_name, boo
 
 	// First, make a folder in the My Outfits directory.
 	const LLUUID parent_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_MY_OUTFITS);
-    if (AISAPI::isAvailable())
-	{
-		// cap-based category creation was buggy until recently. use
-		// existence of AIS as an indicator the fix is present. Does
-		// not actually use AIS to create the category.
-		inventory_func_type func = boost::bind(&LLAppearanceMgr::onOutfitFolderCreated,this,_1,show_panel);
-		gInventory.createNewCategory(
-			parent_id,
-			LLFolderType::FT_OUTFIT,
-			new_folder_name,
-			func);
-	}
-	else
-	{		
-		LLUUID folder_id = gInventory.createNewCategory(
-			parent_id,
-			LLFolderType::FT_OUTFIT,
-			new_folder_name);
-		onOutfitFolderCreated(folder_id, show_panel);
-	}
+
+    gInventory.createNewCategory(
+        parent_id,
+        LLFolderType::FT_OUTFIT,
+        new_folder_name,
+        [show_panel](const LLUUID &new_cat_id)
+        {
+            LLAppearanceMgr::getInstance()->onOutfitFolderCreated(new_cat_id, show_panel);
+        });
 }
 
 void LLAppearanceMgr::wearBaseOutfit()
@@ -4333,6 +4434,70 @@ public:
 	~CallAfterCategoryFetchStage1()
 	{
 	}
+    /*virtual*/ void startFetch()
+    {
+        bool ais3 = AISAPI::isAvailable();
+        for (uuid_vec_t::const_iterator it = mIDs.begin(); it != mIDs.end(); ++it)
+        {
+            LLViewerInventoryCategory* cat = gInventory.getCategory(*it);
+            if (!cat) continue;
+            if (!isCategoryComplete(cat))
+            {
+                // CHECK IT: isCategoryComplete() checks both version and descendant count but
+                // fetch() only works for Unknown version and doesn't care about descentants,
+                // as result fetch won't start and folder will potentially get stuck as
+                // incomplete in observer.
+                // Likely either both should use only version or both should check descendants.
+                cat->fetch();		//blindly fetch it without seeing if anything else is fetching it.
+                mIncomplete.push_back(*it);	//Add to list of things being downloaded for this observer.
+            }
+            else if (ais3)
+            {
+                LLInventoryModel::cat_array_t* cats;
+                LLInventoryModel::item_array_t* items;
+                gInventory.getDirectDescendentsOf(cat->getUUID(), cats, items);
+
+                if (items)
+                {
+                    S32 complete_count = 0;
+                    S32 incomplete_count = 0;
+                    for (LLInventoryModel::item_array_t::const_iterator it = items->begin(); it < items->end(); ++it)
+                    {
+                        if (!(*it)->isFinished())
+                        {
+                            incomplete_count++;
+                        }
+                        else
+                        {
+                            complete_count++;
+                        }
+                    }
+                    // AIS can fetch couple items, but if there
+                    // is more than a dozen it will be very slow
+                    // it's faster to get whole folder in such case
+                    const S32 MAX_INDIVIDUAL_FETCH = 10;
+                    if (incomplete_count > MAX_INDIVIDUAL_FETCH
+                        || (incomplete_count > 1 && complete_count == 0))
+                    {
+                        // To prevent premature removal from mIncomplete and
+                        // since we are doing a full refetch anyway, mark unknown
+                        cat->setVersion(LLViewerInventoryCategory::VERSION_UNKNOWN);
+                        cat->fetch();
+                        mIncomplete.push_back(*it);
+                    }
+                    else
+                    {
+                        // let stage2 handle incomplete ones
+                        mComplete.push_back(*it);
+                    }
+                }
+            }
+            else
+            {
+                mComplete.push_back(*it);
+            }
+        }
+    }
 	virtual void done()
 	{
         if (mComplete.size() <= 0)