Merge branch 'main' into marchcat/x-b-merge

# Conflicts:
#	autobuild.xml
#	indra/cmake/ConfigurePkgConfig.cmake
#	indra/cmake/ICU4C.cmake
#	indra/media_plugins/gstreamer010/llmediaimplgstreamer_syms.cpp
#	indra/media_plugins/gstreamer010/llmediaimplgstreamer_syms.h
#	indra/media_plugins/gstreamer010/llmediaimplgstreamertriviallogging.h
#	indra/media_plugins/gstreamer010/llmediaimplgstreamervidplug.cpp
#	indra/media_plugins/gstreamer010/llmediaimplgstreamervidplug.h
#	indra/media_plugins/gstreamer010/media_plugin_gstreamer010.cpp
#	indra/newview/llappviewerlinux_api.h
#	indra/newview/llappviewerlinux_api_dbus.cpp
#	indra/newview/llappviewerlinux_api_dbus.h
#	indra/newview/llfloateremojipicker.cpp
#	indra/newview/lloutfitslist.cpp

1 files changed, 494 insertions, 494 deletions

diff --git a/indra/newview/llinventorymodelbackgroundfetch.cpp b/indra/newview/llinventorymodelbackgroundfetch.cpp
index 7335d1e4fe..77cf5bdcf2 100644
--- a/indra/newview/llinventorymodelbackgroundfetch.cpp
+++ b/indra/newview/llinventorymodelbackgroundfetch.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llinventorymodelbackgroundfetch.cpp
  * @brief Implementation of background fetching of inventory.
  *
  * $LicenseInfo:firstyear=2002&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2014, 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$
  */
@@ -111,23 +111,23 @@ namespace
 //
 class BGItemHttpHandler : public LLInventoryModel::FetchItemHttpHandler
 {
-	LOG_CLASS(BGItemHttpHandler);
-	
+    LOG_CLASS(BGItemHttpHandler);
+
 public:
-	BGItemHttpHandler(const LLSD & request_sd)
-		: LLInventoryModel::FetchItemHttpHandler(request_sd)
-		{
-			LLInventoryModelBackgroundFetch::instance().incrFetchCount(1);
-		}
+    BGItemHttpHandler(const LLSD & request_sd)
+        : LLInventoryModel::FetchItemHttpHandler(request_sd)
+        {
+            LLInventoryModelBackgroundFetch::instance().incrFetchCount(1);
+        }
 
-	virtual ~BGItemHttpHandler()
-		{
-			LLInventoryModelBackgroundFetch::instance().incrFetchCount(-1);
-		}
+    virtual ~BGItemHttpHandler()
+        {
+            LLInventoryModelBackgroundFetch::instance().incrFetchCount(-1);
+        }
 
 protected:
-	BGItemHttpHandler(const BGItemHttpHandler &);				// Not defined
-	void operator=(const BGItemHttpHandler &);					// Not defined
+    BGItemHttpHandler(const BGItemHttpHandler &);               // Not defined
+    void operator=(const BGItemHttpHandler &);                  // Not defined
 };
 
 
@@ -142,39 +142,39 @@ protected:
 //
 class BGFolderHttpHandler : public LLCore::HttpHandler
 {
-	LOG_CLASS(BGFolderHttpHandler);
-	
+    LOG_CLASS(BGFolderHttpHandler);
+
 public:
-	BGFolderHttpHandler(const LLSD & request_sd, const uuid_vec_t & recursive_cats)
-		: LLCore::HttpHandler(),
-		  mRequestSD(request_sd),
-		  mRecursiveCatUUIDs(recursive_cats)
-		{
-			LLInventoryModelBackgroundFetch::instance().incrFetchCount(1);
-		}
-
-	virtual ~BGFolderHttpHandler()
-		{
-			LLInventoryModelBackgroundFetch::instance().incrFetchCount(-1);
-		}
-	
+    BGFolderHttpHandler(const LLSD & request_sd, const uuid_vec_t & recursive_cats)
+        : LLCore::HttpHandler(),
+          mRequestSD(request_sd),
+          mRecursiveCatUUIDs(recursive_cats)
+        {
+            LLInventoryModelBackgroundFetch::instance().incrFetchCount(1);
+        }
+
+    virtual ~BGFolderHttpHandler()
+        {
+            LLInventoryModelBackgroundFetch::instance().incrFetchCount(-1);
+        }
+
 protected:
-	BGFolderHttpHandler(const BGFolderHttpHandler &);			// Not defined
-	void operator=(const BGFolderHttpHandler &);				// Not defined
+    BGFolderHttpHandler(const BGFolderHttpHandler &);           // Not defined
+    void operator=(const BGFolderHttpHandler &);                // Not defined
 
 public:
-	virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);
+    virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);
 
-	bool getIsRecursive(const LLUUID & cat_id) const;
+    bool getIsRecursive(const LLUUID & cat_id) const;
 
 private:
-	void processData(LLSD & body, LLCore::HttpResponse * response);
-	void processFailure(LLCore::HttpStatus status, LLCore::HttpResponse * response);
-	void processFailure(const char * const reason, LLCore::HttpResponse * response);
+    void processData(LLSD & body, LLCore::HttpResponse * response);
+    void processFailure(LLCore::HttpStatus status, LLCore::HttpResponse * response);
+    void processFailure(const char * const reason, LLCore::HttpResponse * response);
 
 private:
-	LLSD mRequestSD;
-	const uuid_vec_t mRecursiveCatUUIDs; // hack for storing away which cat fetches are recursive
+    LLSD mRequestSD;
+    const uuid_vec_t mRecursiveCatUUIDs; // hack for storing away which cat fetches are recursive
 };
 
 
@@ -188,9 +188,9 @@ const char * const LOG_INV("Inventory");
 ///----------------------------------------------------------------------------
 
 LLInventoryModelBackgroundFetch::LLInventoryModelBackgroundFetch():
-	mBackgroundFetchActive(false),
-	mFolderFetchActive(false),
-	mFetchCount(0),
+    mBackgroundFetchActive(false),
+    mFolderFetchActive(false),
+    mFetchCount(0),
     mLastFetchCount(0),
     mFetchFolderCount(0),
     mAllRecursiveFoldersFetched(false),
@@ -207,7 +207,7 @@ LLInventoryModelBackgroundFetch::~LLInventoryModelBackgroundFetch()
 
 bool LLInventoryModelBackgroundFetch::isBulkFetchProcessingComplete() const
 {
-	return mFetchFolderQueue.empty() && mFetchItemQueue.empty() && mFetchCount <= 0;
+    return mFetchFolderQueue.empty() && mFetchItemQueue.empty() && mFetchCount <= 0;
 }
 
 bool LLInventoryModelBackgroundFetch::isFolderFetchProcessingComplete() const
@@ -217,42 +217,42 @@ bool LLInventoryModelBackgroundFetch::isFolderFetchProcessingComplete() const
 
 bool LLInventoryModelBackgroundFetch::libraryFetchStarted() const
 {
-	return mRecursiveLibraryFetchStarted;
+    return mRecursiveLibraryFetchStarted;
 }
 
 bool LLInventoryModelBackgroundFetch::libraryFetchCompleted() const
 {
-	return libraryFetchStarted() && fetchQueueContainsNoDescendentsOf(gInventory.getLibraryRootFolderID());
+    return libraryFetchStarted() && fetchQueueContainsNoDescendentsOf(gInventory.getLibraryRootFolderID());
 }
 
 bool LLInventoryModelBackgroundFetch::libraryFetchInProgress() const
 {
-	return libraryFetchStarted() && !libraryFetchCompleted();
+    return libraryFetchStarted() && !libraryFetchCompleted();
 }
-	
+
 bool LLInventoryModelBackgroundFetch::inventoryFetchStarted() const
 {
-	return mRecursiveInventoryFetchStarted;
+    return mRecursiveInventoryFetchStarted;
 }
 
 bool LLInventoryModelBackgroundFetch::inventoryFetchCompleted() const
 {
-	return inventoryFetchStarted() && fetchQueueContainsNoDescendentsOf(gInventory.getRootFolderID());
+    return inventoryFetchStarted() && fetchQueueContainsNoDescendentsOf(gInventory.getRootFolderID());
 }
 
 bool LLInventoryModelBackgroundFetch::inventoryFetchInProgress() const
 {
-	return inventoryFetchStarted() && ! inventoryFetchCompleted();
+    return inventoryFetchStarted() && ! inventoryFetchCompleted();
 }
 
 bool LLInventoryModelBackgroundFetch::isEverythingFetched() const
 {
-	return mAllRecursiveFoldersFetched;
+    return mAllRecursiveFoldersFetched;
 }
 
 BOOL LLInventoryModelBackgroundFetch::folderFetchActive() const
 {
-	return mFolderFetchActive;
+    return mFolderFetchActive;
 }
 
 void LLInventoryModelBackgroundFetch::addRequestAtFront(const LLUUID & id, bool recursive, bool is_category)
@@ -283,21 +283,21 @@ void LLInventoryModelBackgroundFetch::addRequestAtBack(const LLUUID & id, bool r
 
 void LLInventoryModelBackgroundFetch::start(const LLUUID& id, bool recursive)
 {
-	LLViewerInventoryCategory * cat(gInventory.getCategory(id));
+    LLViewerInventoryCategory * cat(gInventory.getCategory(id));
 
-	if (cat || (id.isNull() && ! isEverythingFetched()))
-	{
-		// it's a folder, do a bulk fetch
-		LL_DEBUGS(LOG_INV) << "Start fetching category: " << id << ", recursive: " << recursive << LL_ENDL;
+    if (cat || (id.isNull() && ! isEverythingFetched()))
+    {
+        // it's a folder, do a bulk fetch
+        LL_DEBUGS(LOG_INV) << "Start fetching category: " << id << ", recursive: " << recursive << LL_ENDL;
 
-		mBackgroundFetchActive = true;
-		mFolderFetchActive = true;
+        mBackgroundFetchActive = true;
+        mFolderFetchActive = true;
         EFetchType recursion_type = recursive ? FT_RECURSIVE : FT_DEFAULT;
-		if (id.isNull())
-		{
-			if (! mRecursiveInventoryFetchStarted)
-			{
-				mRecursiveInventoryFetchStarted |= recursive;
+        if (id.isNull())
+        {
+            if (! mRecursiveInventoryFetchStarted)
+            {
+                mRecursiveInventoryFetchStarted |= recursive;
                 if (recursive && AISAPI::isAvailable())
                 {
                     // Not only root folder can be massive, but
@@ -309,15 +309,15 @@ void LLInventoryModelBackgroundFetch::start(const LLUUID& id, bool recursive)
                 {
                     mFetchFolderQueue.push_back(FetchQueueInfo(gInventory.getRootFolderID(), recursion_type));
                 }
-				gIdleCallbacks.addFunction(&LLInventoryModelBackgroundFetch::backgroundFetchCB, NULL);
-			}
-			if (! mRecursiveLibraryFetchStarted)
-			{
-				mRecursiveLibraryFetchStarted |= recursive;
+                gIdleCallbacks.addFunction(&LLInventoryModelBackgroundFetch::backgroundFetchCB, NULL);
+            }
+            if (! mRecursiveLibraryFetchStarted)
+            {
+                mRecursiveLibraryFetchStarted |= recursive;
                 mFetchFolderQueue.push_back(FetchQueueInfo(gInventory.getLibraryRootFolderID(), recursion_type));
-				gIdleCallbacks.addFunction(&LLInventoryModelBackgroundFetch::backgroundFetchCB, NULL);
-			}
-		}
+                gIdleCallbacks.addFunction(&LLInventoryModelBackgroundFetch::backgroundFetchCB, NULL);
+            }
+        }
         else if (recursive && cat && cat->getPreferredType() == LLFolderType::FT_MARKETPLACE_LISTINGS)
         {
             if (mFetchFolderQueue.empty() || mFetchFolderQueue.back().mUUID != id)
@@ -335,8 +335,8 @@ void LLInventoryModelBackgroundFetch::start(const LLUUID& id, bool recursive)
                 mRecursiveMarketplaceFetchStarted = true;
             }
         }
-		else
-		{
+        else
+        {
             if (AISAPI::isAvailable())
             {
                 if (mFetchFolderQueue.empty() || mFetchFolderQueue.back().mUUID != id)
@@ -354,23 +354,23 @@ void LLInventoryModelBackgroundFetch::start(const LLUUID& id, bool recursive)
                     gIdleCallbacks.addFunction(&LLInventoryModelBackgroundFetch::backgroundFetchCB, NULL);
             }
 
-			if (id == gInventory.getLibraryRootFolderID())
-			{
-				mRecursiveLibraryFetchStarted |= recursive;
-			}
-			if (id == gInventory.getRootFolderID())
-			{
-				mRecursiveInventoryFetchStarted |= recursive;
-			}
-		}
-	}
-	else if (LLViewerInventoryItem * itemp = gInventory.getItem(id))
-	{
-		if (! itemp->mIsComplete)
-		{
+            if (id == gInventory.getLibraryRootFolderID())
+            {
+                mRecursiveLibraryFetchStarted |= recursive;
+            }
+            if (id == gInventory.getRootFolderID())
+            {
+                mRecursiveInventoryFetchStarted |= recursive;
+            }
+        }
+    }
+    else if (LLViewerInventoryItem * itemp = gInventory.getItem(id))
+    {
+        if (! itemp->mIsComplete)
+        {
             scheduleItemFetch(id);
-		}
-	}
+        }
+    }
 }
 
 void LLInventoryModelBackgroundFetch::scheduleFolderFetch(const LLUUID& cat_id, bool forced)
@@ -505,15 +505,15 @@ void LLInventoryModelBackgroundFetch::findLostItems()
 
 void LLInventoryModelBackgroundFetch::setAllFoldersFetched()
 {
-	if (mRecursiveInventoryFetchStarted &&
-		mRecursiveLibraryFetchStarted)
-	{
+    if (mRecursiveInventoryFetchStarted &&
+        mRecursiveLibraryFetchStarted)
+    {
         mAllRecursiveFoldersFetched = true;
-		//LL_INFOS(LOG_INV) << "All folders fetched, validating" << LL_ENDL;
-		//gInventory.validate();
-	}
+        //LL_INFOS(LOG_INV) << "All folders fetched, validating" << LL_ENDL;
+        //gInventory.validate();
+    }
 
-	mFolderFetchActive = false;
+    mFolderFetchActive = false;
     if (isBulkFetchProcessingComplete())
     {
         mBackgroundFetchActive = false;
@@ -522,7 +522,7 @@ void LLInventoryModelBackgroundFetch::setAllFoldersFetched()
     // For now only informs about initial fetch being done
     mFoldersFetchedSignal();
 
-	LL_INFOS(LOG_INV) << "Inventory background fetch completed" << LL_ENDL;
+    LL_INFOS(LOG_INV) << "Inventory background fetch completed" << LL_ENDL;
 }
 
 boost::signals2::connection LLInventoryModelBackgroundFetch::setFetchCompletionCallback(folders_fetched_callback_t cb)
@@ -532,13 +532,13 @@ boost::signals2::connection LLInventoryModelBackgroundFetch::setFetchCompletionC
 
 void LLInventoryModelBackgroundFetch::backgroundFetchCB(void *)
 {
-	LLInventoryModelBackgroundFetch::instance().backgroundFetch();
+    LLInventoryModelBackgroundFetch::instance().backgroundFetch();
 }
 
 void LLInventoryModelBackgroundFetch::backgroundFetch()
 {
-	if (mBackgroundFetchActive)
-	{
+    if (mBackgroundFetchActive)
+    {
         if (AISAPI::isAvailable())
         {
             bulkFetchViaAis();
@@ -548,17 +548,17 @@ void LLInventoryModelBackgroundFetch::backgroundFetch()
             // If we'll be using the capability, we'll be sending batches and the background thing isn't as important.
             bulkFetch();
         }
-	}
+    }
 }
 
-void LLInventoryModelBackgroundFetch::incrFetchCount(S32 fetching) 
-{  
-	mFetchCount += fetching; 
-	if (mFetchCount < 0)
-	{
-		LL_WARNS_ONCE(LOG_INV) << "Inventory fetch count fell below zero (0)." << LL_ENDL;
-		mFetchCount = 0; 
-	}
+void LLInventoryModelBackgroundFetch::incrFetchCount(S32 fetching)
+{
+    mFetchCount += fetching;
+    if (mFetchCount < 0)
+    {
+        LL_WARNS_ONCE(LOG_INV) << "Inventory fetch count fell below zero (0)." << LL_ENDL;
+        mFetchCount = 0;
+    }
 }
 void LLInventoryModelBackgroundFetch::incrFetchFolderCount(S32 fetching)
 {
@@ -760,7 +760,7 @@ void LLInventoryModelBackgroundFetch::bulkFetchViaAis()
     F64 curent_time = LLTimer::getTotalSeconds();
     const F64 max_time = LLStartUp::getStartupState() > STATE_WEARABLES_WAIT
         ? 0.006f // 6 ms
-        : 1.f; 
+        : 1.f;
     const F64 end_time = curent_time + max_time;
     S32 last_fetch_count = mFetchCount;
 
@@ -817,7 +817,7 @@ void LLInventoryModelBackgroundFetch::bulkFetchViaAis()
             LL_CONT << LL_ENDL;
         }
     }
-    
+
     if (isFolderFetchProcessingComplete() && mFolderFetchActive)
     {
         if (!mRecursiveInventoryFetchStarted || mRecursiveMarketplaceFetchStarted)
@@ -839,7 +839,7 @@ void LLInventoryModelBackgroundFetch::bulkFetchViaAis()
                 setAllFoldersFetched();
             }
         }
-        
+
     }
 
     if (isBulkFetchProcessingComplete())
@@ -1046,75 +1046,75 @@ void LLInventoryModelBackgroundFetch::bulkFetchViaAis(const FetchQueueInfo& fetc
 // Bundle up a bunch of requests to send all at once.
 void LLInventoryModelBackgroundFetch::bulkFetch()
 {
-	LL_RECORD_BLOCK_TIME(FTM_BULK_FETCH);
-	//Background fetch is called from gIdleCallbacks in a loop until background fetch is stopped.
-	//If there are items in mFetchQueue, we want to check the time since the last bulkFetch was 
-	//sent.  If it exceeds our retry time, go ahead and fire off another batch.  
-	LLViewerRegion * region(gAgent.getRegion());
-	if (! region || gDisconnected || LLApp::isExiting())
-	{
-		return;
-	}
-
-	// *TODO:  These values could be tweaked at runtime to effect
-	// a fast/slow fetch throttle.  Once login is complete and the scene
-	// is mostly loaded, we could turn up the throttle and fill missing
-	// inventory more quickly.
-	static const U32 max_batch_size(10);
-	static const S32 max_concurrent_fetches(12);		// Outstanding requests, not connections
-
-	if (mFetchCount)
-	{
-		// Process completed background HTTP requests
-		gInventory.handleResponses(false);
-		// Just processed a bunch of items.
-		// Note: do we really need notifyObservers() here?
-		// OnIdle it will be called anyway due to Add flag for processed item.
-		// It seems like in some cases we are updaiting on fail (no flag),
-		// but is there anything to update?
-		gInventory.notifyObservers();
-	}
-	
-	if (mFetchCount > max_concurrent_fetches)
-	{
-		return;
-	}
-
-	U32 item_count(0);
-	U32 folder_count(0);
-
-	const U32 sort_order(gSavedSettings.getU32(LLInventoryPanel::DEFAULT_SORT_ORDER) & 0x1);
-
-	// *TODO:  Think I'd like to get a shared pointer to this and share it
-	// among all the folder requests.
-	uuid_vec_t recursive_cats;
+    LL_RECORD_BLOCK_TIME(FTM_BULK_FETCH);
+    //Background fetch is called from gIdleCallbacks in a loop until background fetch is stopped.
+    //If there are items in mFetchQueue, we want to check the time since the last bulkFetch was
+    //sent.  If it exceeds our retry time, go ahead and fire off another batch.
+    LLViewerRegion * region(gAgent.getRegion());
+    if (! region || gDisconnected || LLApp::isExiting())
+    {
+        return;
+    }
+
+    // *TODO:  These values could be tweaked at runtime to effect
+    // a fast/slow fetch throttle.  Once login is complete and the scene
+    // is mostly loaded, we could turn up the throttle and fill missing
+    // inventory more quickly.
+    static const U32 max_batch_size(10);
+    static const S32 max_concurrent_fetches(12);        // Outstanding requests, not connections
+
+    if (mFetchCount)
+    {
+        // Process completed background HTTP requests
+        gInventory.handleResponses(false);
+        // Just processed a bunch of items.
+        // Note: do we really need notifyObservers() here?
+        // OnIdle it will be called anyway due to Add flag for processed item.
+        // It seems like in some cases we are updaiting on fail (no flag),
+        // but is there anything to update?
+        gInventory.notifyObservers();
+    }
+
+    if (mFetchCount > max_concurrent_fetches)
+    {
+        return;
+    }
+
+    U32 item_count(0);
+    U32 folder_count(0);
+
+    const U32 sort_order(gSavedSettings.getU32(LLInventoryPanel::DEFAULT_SORT_ORDER) & 0x1);
+
+    // *TODO:  Think I'd like to get a shared pointer to this and share it
+    // among all the folder requests.
+    uuid_vec_t recursive_cats;
     uuid_vec_t all_cats; // dupplicate avoidance
 
-	LLSD folder_request_body;
-	LLSD folder_request_body_lib;
-	LLSD item_request_body;
-	LLSD item_request_body_lib;
-
-	while (! mFetchFolderQueue.empty() 
-			&& (item_count + folder_count) < max_batch_size)
-	{
-		const FetchQueueInfo & fetch_info(mFetchFolderQueue.front());
-		if (fetch_info.mIsCategory)
-		{
-			const LLUUID & cat_id(fetch_info.mUUID);
-			if (cat_id.isNull()) //DEV-17797 Lost and found
-			{
-				LLSD folder_sd;
-				folder_sd["folder_id"]		= LLUUID::null.asString();
-				folder_sd["owner_id"]		= gAgent.getID();
-				folder_sd["sort_order"]		= LLSD::Integer(sort_order);
-				folder_sd["fetch_folders"]	= LLSD::Boolean(false);
-				folder_sd["fetch_items"]	= LLSD::Boolean(true);
-				folder_request_body["folders"].append(folder_sd);
-				folder_count++;
-			}
-			else
-			{
+    LLSD folder_request_body;
+    LLSD folder_request_body_lib;
+    LLSD item_request_body;
+    LLSD item_request_body_lib;
+
+    while (! mFetchFolderQueue.empty()
+            && (item_count + folder_count) < max_batch_size)
+    {
+        const FetchQueueInfo & fetch_info(mFetchFolderQueue.front());
+        if (fetch_info.mIsCategory)
+        {
+            const LLUUID & cat_id(fetch_info.mUUID);
+            if (cat_id.isNull()) //DEV-17797 Lost and found
+            {
+                LLSD folder_sd;
+                folder_sd["folder_id"]      = LLUUID::null.asString();
+                folder_sd["owner_id"]       = gAgent.getID();
+                folder_sd["sort_order"]     = LLSD::Integer(sort_order);
+                folder_sd["fetch_folders"]  = LLSD::Boolean(false);
+                folder_sd["fetch_items"]    = LLSD::Boolean(true);
+                folder_request_body["folders"].append(folder_sd);
+                folder_count++;
+            }
+            else
+            {
                 const LLViewerInventoryCategory * cat(gInventory.getCategory(cat_id));
                 if (cat)
                 {
@@ -1157,13 +1157,13 @@ void LLInventoryModelBackgroundFetch::bulkFetch()
                         }
                     }
                 }
-			}
-			if (fetch_info.mFetchType >= FT_CONTENT_RECURSIVE)
-			{
-				recursive_cats.push_back(cat_id);
-			}
+            }
+            if (fetch_info.mFetchType >= FT_CONTENT_RECURSIVE)
+            {
+                recursive_cats.push_back(cat_id);
+            }
             all_cats.push_back(cat_id);
-		}
+        }
 
         mFetchFolderQueue.pop_front();
     }
@@ -1194,84 +1194,84 @@ void LLInventoryModelBackgroundFetch::bulkFetch()
         }
 
         mFetchItemQueue.pop_front();
-	}
-
-	// Issue HTTP POST requests to fetch folders and items
-	
-	if (item_count + folder_count > 0)
-	{
-		if (folder_count)
-		{
-			if (folder_request_body["folders"].size())
-			{
-				const std::string url(region->getCapability("FetchInventoryDescendents2"));
-
-				if (! url.empty())
-				{
+    }
+
+    // Issue HTTP POST requests to fetch folders and items
+
+    if (item_count + folder_count > 0)
+    {
+        if (folder_count)
+        {
+            if (folder_request_body["folders"].size())
+            {
+                const std::string url(region->getCapability("FetchInventoryDescendents2"));
+
+                if (! url.empty())
+                {
                     LLCore::HttpHandler::ptr_t  handler(new BGFolderHttpHandler(folder_request_body, recursive_cats));
-					gInventory.requestPost(false, url, folder_request_body, handler, "Inventory Folder");
-				}
-			}
-			
-			if (folder_request_body_lib["folders"].size())
-			{
-				const std::string url(region->getCapability("FetchLibDescendents2"));
-
-				if (! url.empty())
-				{
+                    gInventory.requestPost(false, url, folder_request_body, handler, "Inventory Folder");
+                }
+            }
+
+            if (folder_request_body_lib["folders"].size())
+            {
+                const std::string url(region->getCapability("FetchLibDescendents2"));
+
+                if (! url.empty())
+                {
                     LLCore::HttpHandler::ptr_t  handler(new BGFolderHttpHandler(folder_request_body_lib, recursive_cats));
-					gInventory.requestPost(false, url, folder_request_body_lib, handler, "Library Folder");
-				}
-			}
-		} // if (folder_count)
-
-		if (item_count)
-		{
-			if (item_request_body.size())
-			{
-				const std::string url(region->getCapability("FetchInventory2"));
-
-				if (! url.empty())
-				{
-					LLSD body;
-					body["items"] = item_request_body;
+                    gInventory.requestPost(false, url, folder_request_body_lib, handler, "Library Folder");
+                }
+            }
+        } // if (folder_count)
+
+        if (item_count)
+        {
+            if (item_request_body.size())
+            {
+                const std::string url(region->getCapability("FetchInventory2"));
+
+                if (! url.empty())
+                {
+                    LLSD body;
+                    body["items"] = item_request_body;
                     LLCore::HttpHandler::ptr_t  handler(new BGItemHttpHandler(body));
-					gInventory.requestPost(false, url, body, handler, "Inventory Item");
-				}
-			}
-
-			if (item_request_body_lib.size())
-			{
-				const std::string url(region->getCapability("FetchLib2"));
-
-				if (! url.empty())
-				{
-					LLSD body;
-					body["items"] = item_request_body_lib;
+                    gInventory.requestPost(false, url, body, handler, "Inventory Item");
+                }
+            }
+
+            if (item_request_body_lib.size())
+            {
+                const std::string url(region->getCapability("FetchLib2"));
+
+                if (! url.empty())
+                {
+                    LLSD body;
+                    body["items"] = item_request_body_lib;
                     LLCore::HttpHandler::ptr_t handler(new BGItemHttpHandler(body));
-					gInventory.requestPost(false, url, body, handler, "Library Item");
-				}
-			}
-		} // if (item_count)
-		
-		mFetchTimer.reset();
-	}
-	else if (isBulkFetchProcessingComplete())
-	{
-		setAllFoldersFetched();
-	}
+                    gInventory.requestPost(false, url, body, handler, "Library Item");
+                }
+            }
+        } // if (item_count)
+
+        mFetchTimer.reset();
+    }
+    else if (isBulkFetchProcessingComplete())
+    {
+        setAllFoldersFetched();
+    }
 }
 
 bool LLInventoryModelBackgroundFetch::fetchQueueContainsNoDescendentsOf(const LLUUID & cat_id) const
 {
-	for (fetch_queue_t::const_iterator it = mFetchFolderQueue.begin();
-		 it != mFetchFolderQueue.end();
-		 ++it)
-	{
-		const LLUUID & fetch_id = (*it).mUUID;
-		if (gInventory.isObjectDescendentOf(fetch_id, cat_id))
-			return false;
-	}
+    for (fetch_queue_t::const_iterator it = mFetchFolderQueue.begin();
+         it != mFetchFolderQueue.end();
+         ++it)
+    {
+        const LLUUID & fetch_id = (*it).mUUID;
+        if (gInventory.isObjectDescendentOf(fetch_id, cat_id))
+            return false;
+    }
     for (fetch_queue_t::const_iterator it = mFetchItemQueue.begin();
         it != mFetchItemQueue.end();
         ++it)
@@ -1280,7 +1280,7 @@ bool LLInventoryModelBackgroundFetch::fetchQueueContainsNoDescendentsOf(const LL
         if (gInventory.isObjectDescendentOf(fetch_id, cat_id))
             return false;
     }
-	return true;
+    return true;
 }
 
 
@@ -1293,116 +1293,116 @@ namespace
 
 void BGFolderHttpHandler::onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response)
 {
-	do  	// Single-pass do-while used for common exit handling
-	{
-		LLCore::HttpStatus status(response->getStatus());
-		// status = LLCore::HttpStatus(404);				// Dev tool to force error handling
-		if (! status)
-		{
-			processFailure(status, response);
-			break;			// Goto common exit
-		}
-
-		// Response body should be present.
-		LLCore::BufferArray * body(response->getBody());
-		// body = NULL;									// Dev tool to force error handling
-		if (! body || ! body->size())
-		{
-			LL_WARNS(LOG_INV) << "Missing data in inventory folder query." << LL_ENDL;
-			processFailure("HTTP response missing expected body", response);
-			break;			// Goto common exit
-		}
-
-		// Could test 'Content-Type' header but probably unreliable.
-
-		// Convert response to LLSD
-		// body->write(0, "Garbage Response", 16);		// Dev tool to force error handling
-		LLSD body_llsd;
-		if (! LLCoreHttpUtil::responseToLLSD(response, true, body_llsd))
-		{
-			// INFOS-level logging will occur on the parsed failure
-			processFailure("HTTP response contained malformed LLSD", response);
-			break;			// goto common exit
-		}
-
-		// Expect top-level structure to be a map
-		// body_llsd = LLSD::emptyArray();				// Dev tool to force error handling
-		if (! body_llsd.isMap())
-		{
-			processFailure("LLSD response not a map", response);
-			break;			// goto common exit
-		}
-
-		// Check for 200-with-error failures
-		//
-		// See comments in llinventorymodel.cpp about this mode of error.
-		//
-		// body_llsd["error"] = LLSD::emptyMap();		// Dev tool to force error handling
-		// body_llsd["error"]["identifier"] = "Development";
-		// body_llsd["error"]["message"] = "You left development code in the viewer";
-		if (body_llsd.has("error"))
-		{
-			processFailure("Inventory application error (200-with-error)", response);
-			break;			// goto common exit
-		}
-
-		// Okay, process data if possible
-		processData(body_llsd, response);
-	}
-	while (false);
+    do      // Single-pass do-while used for common exit handling
+    {
+        LLCore::HttpStatus status(response->getStatus());
+        // status = LLCore::HttpStatus(404);                // Dev tool to force error handling
+        if (! status)
+        {
+            processFailure(status, response);
+            break;          // Goto common exit
+        }
+
+        // Response body should be present.
+        LLCore::BufferArray * body(response->getBody());
+        // body = NULL;                                 // Dev tool to force error handling
+        if (! body || ! body->size())
+        {
+            LL_WARNS(LOG_INV) << "Missing data in inventory folder query." << LL_ENDL;
+            processFailure("HTTP response missing expected body", response);
+            break;          // Goto common exit
+        }
+
+        // Could test 'Content-Type' header but probably unreliable.
+
+        // Convert response to LLSD
+        // body->write(0, "Garbage Response", 16);      // Dev tool to force error handling
+        LLSD body_llsd;
+        if (! LLCoreHttpUtil::responseToLLSD(response, true, body_llsd))
+        {
+            // INFOS-level logging will occur on the parsed failure
+            processFailure("HTTP response contained malformed LLSD", response);
+            break;          // goto common exit
+        }
+
+        // Expect top-level structure to be a map
+        // body_llsd = LLSD::emptyArray();              // Dev tool to force error handling
+        if (! body_llsd.isMap())
+        {
+            processFailure("LLSD response not a map", response);
+            break;          // goto common exit
+        }
+
+        // Check for 200-with-error failures
+        //
+        // See comments in llinventorymodel.cpp about this mode of error.
+        //
+        // body_llsd["error"] = LLSD::emptyMap();       // Dev tool to force error handling
+        // body_llsd["error"]["identifier"] = "Development";
+        // body_llsd["error"]["message"] = "You left development code in the viewer";
+        if (body_llsd.has("error"))
+        {
+            processFailure("Inventory application error (200-with-error)", response);
+            break;          // goto common exit
+        }
+
+        // Okay, process data if possible
+        processData(body_llsd, response);
+    }
+    while (false);
 }
 
 
 void BGFolderHttpHandler::processData(LLSD & content, LLCore::HttpResponse * response)
 {
-	LLInventoryModelBackgroundFetch * fetcher(LLInventoryModelBackgroundFetch::getInstance());
-
-	// API V2 and earlier should probably be testing for "error" map
-	// in response as an application-level error.
-
-	// Instead, we assume success and attempt to extract information.
-	if (content.has("folders"))	
-	{
-		LLSD folders(content["folders"]);
-		
-		for (LLSD::array_const_iterator folder_it = folders.beginArray();
-			folder_it != folders.endArray();
-			++folder_it)
-		{	
-			LLSD folder_sd(*folder_it);
-
-			//LLUUID agent_id = folder_sd["agent_id"];
-
-			//if(agent_id != gAgent.getID())	//This should never happen.
-			//{
-			//	LL_WARNS(LOG_INV) << "Got a UpdateInventoryItem for the wrong agent."
-			//			<< LL_ENDL;
-			//	break;
-			//}
-
-			LLUUID parent_id(folder_sd["folder_id"].asUUID());
-			LLUUID owner_id(folder_sd["owner_id"].asUUID());
-			S32    version(folder_sd["version"].asInteger());
-			S32    descendents(folder_sd["descendents"].asInteger());
-			LLPointer<LLViewerInventoryCategory> tcategory = new LLViewerInventoryCategory(owner_id);
+    LLInventoryModelBackgroundFetch * fetcher(LLInventoryModelBackgroundFetch::getInstance());
+
+    // API V2 and earlier should probably be testing for "error" map
+    // in response as an application-level error.
+
+    // Instead, we assume success and attempt to extract information.
+    if (content.has("folders"))
+    {
+        LLSD folders(content["folders"]);
+
+        for (LLSD::array_const_iterator folder_it = folders.beginArray();
+            folder_it != folders.endArray();
+            ++folder_it)
+        {
+            LLSD folder_sd(*folder_it);
+
+            //LLUUID agent_id = folder_sd["agent_id"];
+
+            //if(agent_id != gAgent.getID())    //This should never happen.
+            //{
+            //  LL_WARNS(LOG_INV) << "Got a UpdateInventoryItem for the wrong agent."
+            //          << LL_ENDL;
+            //  break;
+            //}
+
+            LLUUID parent_id(folder_sd["folder_id"].asUUID());
+            LLUUID owner_id(folder_sd["owner_id"].asUUID());
+            S32    version(folder_sd["version"].asInteger());
+            S32    descendents(folder_sd["descendents"].asInteger());
+            LLPointer<LLViewerInventoryCategory> tcategory = new LLViewerInventoryCategory(owner_id);
 
             if (parent_id.isNull())
             {
-				LLSD items(folder_sd["items"]);
-			    LLPointer<LLViewerInventoryItem> titem = new LLViewerInventoryItem;
-				
-			    for (LLSD::array_const_iterator item_it = items.beginArray();
-				    item_it != items.endArray();
-				    ++item_it)
-			    {	
+                LLSD items(folder_sd["items"]);
+                LLPointer<LLViewerInventoryItem> titem = new LLViewerInventoryItem;
+
+                for (LLSD::array_const_iterator item_it = items.beginArray();
+                    item_it != items.endArray();
+                    ++item_it)
+                {
                     const LLUUID lost_uuid(gInventory.findCategoryUUIDForType(LLFolderType::FT_LOST_AND_FOUND));
 
                     if (lost_uuid.notNull())
                     {
-				        LLSD item(*item_it);
+                        LLSD item(*item_it);
+
+                        titem->unpackMessage(item);
 
-				        titem->unpackMessage(item);
-				
                         LLInventoryModel::update_list_t update;
                         LLInventoryModel::LLCategoryUpdate new_folder(lost_uuid, 1);
                         update.push_back(new_folder);
@@ -1415,88 +1415,88 @@ void BGFolderHttpHandler::processData(LLSD & content, LLCore::HttpResponse * res
                 }
             }
 
-	        LLViewerInventoryCategory * pcat(gInventory.getCategory(parent_id));
-			if (! pcat)
-			{
-				continue;
-			}
-
-			LLSD categories(folder_sd["categories"]);
-			for (LLSD::array_const_iterator category_it = categories.beginArray();
-				category_it != categories.endArray();
-				++category_it)
-			{	
-				LLSD category(*category_it);
-				tcategory->fromLLSD(category); 
-				
-				const bool recursive(getIsRecursive(tcategory->getUUID()));
-				if (recursive)
-				{
-					fetcher->addRequestAtBack(tcategory->getUUID(), recursive, true);
-				}
-				else if (! gInventory.isCategoryComplete(tcategory->getUUID()))
-				{
-					gInventory.updateCategory(tcategory);
-				}
-			}
-
-			LLSD items(folder_sd["items"]);
-			LLPointer<LLViewerInventoryItem> titem = new LLViewerInventoryItem;
-			for (LLSD::array_const_iterator item_it = items.beginArray();
-				 item_it != items.endArray();
-				 ++item_it)
-			{	
-				LLSD item(*item_it);
-				titem->unpackMessage(item);
-				
-				gInventory.updateItem(titem);
-			}
-
-			// Set version and descendentcount according to message.
-			LLViewerInventoryCategory * cat(gInventory.getCategory(parent_id));
-			if (cat)
-			{
-				cat->setVersion(version);
-				cat->setDescendentCount(descendents);
-				cat->determineFolderType();
-			}
-		}
-	}
-		
-	if (content.has("bad_folders"))
-	{
-		LLSD bad_folders(content["bad_folders"]);
-		for (LLSD::array_const_iterator folder_it = bad_folders.beginArray();
-			 folder_it != bad_folders.endArray();
-			 ++folder_it)
-		{
-			// *TODO: Stop copying data [ed:  this isn't copying data]
-			LLSD folder_sd(*folder_it);
-			
-			// These folders failed on the dataserver.  We probably don't want to retry them.
-			LL_WARNS(LOG_INV) << "Folder " << folder_sd["folder_id"].asString() 
-							  << "Error: " << folder_sd["error"].asString() << LL_ENDL;
-		}
-	}
-	
-	if (fetcher->isBulkFetchProcessingComplete())
-	{
-		fetcher->setAllFoldersFetched();
-	}
+            LLViewerInventoryCategory * pcat(gInventory.getCategory(parent_id));
+            if (! pcat)
+            {
+                continue;
+            }
+
+            LLSD categories(folder_sd["categories"]);
+            for (LLSD::array_const_iterator category_it = categories.beginArray();
+                category_it != categories.endArray();
+                ++category_it)
+            {
+                LLSD category(*category_it);
+                tcategory->fromLLSD(category);
+
+                const bool recursive(getIsRecursive(tcategory->getUUID()));
+                if (recursive)
+                {
+                    fetcher->addRequestAtBack(tcategory->getUUID(), recursive, true);
+                }
+                else if (! gInventory.isCategoryComplete(tcategory->getUUID()))
+                {
+                    gInventory.updateCategory(tcategory);
+                }
+            }
+
+            LLSD items(folder_sd["items"]);
+            LLPointer<LLViewerInventoryItem> titem = new LLViewerInventoryItem;
+            for (LLSD::array_const_iterator item_it = items.beginArray();
+                 item_it != items.endArray();
+                 ++item_it)
+            {
+                LLSD item(*item_it);
+                titem->unpackMessage(item);
+
+                gInventory.updateItem(titem);
+            }
+
+            // Set version and descendentcount according to message.
+            LLViewerInventoryCategory * cat(gInventory.getCategory(parent_id));
+            if (cat)
+            {
+                cat->setVersion(version);
+                cat->setDescendentCount(descendents);
+                cat->determineFolderType();
+            }
+        }
+    }
+
+    if (content.has("bad_folders"))
+    {
+        LLSD bad_folders(content["bad_folders"]);
+        for (LLSD::array_const_iterator folder_it = bad_folders.beginArray();
+             folder_it != bad_folders.endArray();
+             ++folder_it)
+        {
+            // *TODO: Stop copying data [ed:  this isn't copying data]
+            LLSD folder_sd(*folder_it);
+
+            // These folders failed on the dataserver.  We probably don't want to retry them.
+            LL_WARNS(LOG_INV) << "Folder " << folder_sd["folder_id"].asString()
+                              << "Error: " << folder_sd["error"].asString() << LL_ENDL;
+        }
+    }
+
+    if (fetcher->isBulkFetchProcessingComplete())
+    {
+        fetcher->setAllFoldersFetched();
+    }
 }
 
 
 void BGFolderHttpHandler::processFailure(LLCore::HttpStatus status, LLCore::HttpResponse * response)
 {
-	const std::string & ct(response->getContentType());
-	LL_WARNS(LOG_INV) << "Inventory folder fetch failure\n"
-					  << "[Status: " << status.toTerseString() << "]\n"
-					  << "[Reason: " << status.toString() << "]\n"
-					  << "[Content-type: " << ct << "]\n"
-					  << "[Content (abridged): "
-					  << LLCoreHttpUtil::responseToString(response) << "]" << LL_ENDL;
+    const std::string & ct(response->getContentType());
+    LL_WARNS(LOG_INV) << "Inventory folder fetch failure\n"
+                      << "[Status: " << status.toTerseString() << "]\n"
+                      << "[Reason: " << status.toString() << "]\n"
+                      << "[Content-type: " << ct << "]\n"
+                      << "[Content (abridged): "
+                      << LLCoreHttpUtil::responseToString(response) << "]" << LL_ENDL;
 
-	// Could use a 404 test here to try to detect revoked caps...
+    // Could use a 404 test here to try to detect revoked caps...
 
     if(status == LLCore::HttpStatus(HTTP_FORBIDDEN))
     {
@@ -1554,77 +1554,77 @@ void BGFolderHttpHandler::processFailure(LLCore::HttpStatus status, LLCore::Http
             LLNotificationsUtil::add("InventoryLimitReachedAIS");
         }
     }
-	
-	// This was originally the request retry logic for the inventory
-	// request which tested on HTTP_INTERNAL_ERROR status.  This
-	// retry logic was unbounded and lacked discrimination as to the
-	// cause of the retry.  The new http library should be doing
-	// adquately on retries but I want to keep the structure of a
-	// retry for reference.
-	LLInventoryModelBackgroundFetch *fetcher = LLInventoryModelBackgroundFetch::getInstance();
-	if (false)
-	{
-		// timed out or curl failure
-		for (LLSD::array_const_iterator folder_it = mRequestSD["folders"].beginArray();
-			 folder_it != mRequestSD["folders"].endArray();
-			 ++folder_it)
-		{
-			LLSD folder_sd(*folder_it);
-			LLUUID folder_id(folder_sd["folder_id"].asUUID());
-			const BOOL recursive = getIsRecursive(folder_id);
-			fetcher->addRequestAtFront(folder_id, recursive, true);
-		}
-	}
-	else
-	{
-		if (fetcher->isBulkFetchProcessingComplete())
-		{
-			fetcher->setAllFoldersFetched();
-		}
-	}
+
+    // This was originally the request retry logic for the inventory
+    // request which tested on HTTP_INTERNAL_ERROR status.  This
+    // retry logic was unbounded and lacked discrimination as to the
+    // cause of the retry.  The new http library should be doing
+    // adquately on retries but I want to keep the structure of a
+    // retry for reference.
+    LLInventoryModelBackgroundFetch *fetcher = LLInventoryModelBackgroundFetch::getInstance();
+    if (false)
+    {
+        // timed out or curl failure
+        for (LLSD::array_const_iterator folder_it = mRequestSD["folders"].beginArray();
+             folder_it != mRequestSD["folders"].endArray();
+             ++folder_it)
+        {
+            LLSD folder_sd(*folder_it);
+            LLUUID folder_id(folder_sd["folder_id"].asUUID());
+            const BOOL recursive = getIsRecursive(folder_id);
+            fetcher->addRequestAtFront(folder_id, recursive, true);
+        }
+    }
+    else
+    {
+        if (fetcher->isBulkFetchProcessingComplete())
+        {
+            fetcher->setAllFoldersFetched();
+        }
+    }
 }
 
 
 void BGFolderHttpHandler::processFailure(const char * const reason, LLCore::HttpResponse * response)
 {
-	LL_WARNS(LOG_INV) << "Inventory folder fetch failure\n"
-					  << "[Status: internal error]\n"
-					  << "[Reason: " << reason << "]\n"
-					  << "[Content (abridged): "
-					  << LLCoreHttpUtil::responseToString(response) << "]" << LL_ENDL;
-
-	// Reverse of previous processFailure() method, this is invoked
-	// when response structure is found to be invalid.  Original
-	// always re-issued the request (without limit).  This does
-	// the same but be aware that this may be a source of problems.
-	// Philosophy is that inventory folders are so essential to
-	// operation that this is a reasonable action.
-	LLInventoryModelBackgroundFetch *fetcher = LLInventoryModelBackgroundFetch::getInstance();
-	if (true)
-	{
-		for (LLSD::array_const_iterator folder_it = mRequestSD["folders"].beginArray();
-			 folder_it != mRequestSD["folders"].endArray();
-			 ++folder_it)
-		{
-			LLSD folder_sd(*folder_it);
-			LLUUID folder_id(folder_sd["folder_id"].asUUID());
-			const BOOL recursive = getIsRecursive(folder_id);
-			fetcher->addRequestAtFront(folder_id, recursive, true);
-		}
-	}
-	else
-	{
-		if (fetcher->isBulkFetchProcessingComplete())
-		{
-			fetcher->setAllFoldersFetched();
-		}
-	}
+    LL_WARNS(LOG_INV) << "Inventory folder fetch failure\n"
+                      << "[Status: internal error]\n"
+                      << "[Reason: " << reason << "]\n"
+                      << "[Content (abridged): "
+                      << LLCoreHttpUtil::responseToString(response) << "]" << LL_ENDL;
+
+    // Reverse of previous processFailure() method, this is invoked
+    // when response structure is found to be invalid.  Original
+    // always re-issued the request (without limit).  This does
+    // the same but be aware that this may be a source of problems.
+    // Philosophy is that inventory folders are so essential to
+    // operation that this is a reasonable action.
+    LLInventoryModelBackgroundFetch *fetcher = LLInventoryModelBackgroundFetch::getInstance();
+    if (true)
+    {
+        for (LLSD::array_const_iterator folder_it = mRequestSD["folders"].beginArray();
+             folder_it != mRequestSD["folders"].endArray();
+             ++folder_it)
+        {
+            LLSD folder_sd(*folder_it);
+            LLUUID folder_id(folder_sd["folder_id"].asUUID());
+            const BOOL recursive = getIsRecursive(folder_id);
+            fetcher->addRequestAtFront(folder_id, recursive, true);
+        }
+    }
+    else
+    {
+        if (fetcher->isBulkFetchProcessingComplete())
+        {
+            fetcher->setAllFoldersFetched();
+        }
+    }
 }
 
 
 bool BGFolderHttpHandler::getIsRecursive(const LLUUID & cat_id) const
 {
-	return std::find(mRecursiveCatUUIDs.begin(), mRecursiveCatUUIDs.end(), cat_id) != mRecursiveCatUUIDs.end();
+    return std::find(mRecursiveCatUUIDs.begin(), mRecursiveCatUUIDs.end(), cat_id) != mRecursiveCatUUIDs.end();
 }
 
 ///----------------------------------------------------------------------------