Merge downstream code and become 3.7.20

1 files changed, 571 insertions, 294 deletions

diff --git a/indra/newview/llinventorymodelbackgroundfetch.cpp b/indra/newview/llinventorymodelbackgroundfetch.cpp
index 2de37b0790..f18832fe95 100755
--- a/indra/newview/llinventorymodelbackgroundfetch.cpp
+++ b/indra/newview/llinventorymodelbackgroundfetch.cpp
@@ -4,7 +4,7 @@
  *
  * $LicenseInfo:firstyear=2002&license=viewerlgpl$
  * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
+ * 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
@@ -37,31 +37,180 @@
 #include "llviewermessage.h"
 #include "llviewerregion.h"
 #include "llviewerwindow.h"
+#include "llhttpconstants.h"
+#include "bufferarray.h"
+#include "bufferstream.h"
+#include "llcorehttputil.h"
+
+// History (may be apocryphal)
+//
+// Around V2, an HTTP inventory download mechanism was added
+// along with inventory LINK items referencing other inventory
+// items.  As part of this, at login, the entire inventory
+// structure is downloaded 'in the background' using the
+// backgroundFetch()/bulkFetch() methods.  The UDP path can
+// still be used and is found in the 'DEPRECATED OLD CODE'
+// section.
+//
+// The old UDP path implemented a throttle that adapted
+// itself during running.  The mechanism survived info HTTP
+// somewhat but was pinned to poll the HTTP plumbing at
+// 0.5S intervals.  The reasons for this particular value
+// have been lost.  It's possible to switch between UDP
+// and HTTP while this is happening but there may be
+// surprises in what happens in that case.
+//
+// Conversion to llcorehttp reduced the number of connections
+// used but batches more data and queues more requests (but
+// doesn't due pipelining due to libcurl restrictions).  The
+// poll interval above was re-examined and reduced to get
+// inventory into the viewer more quickly.
+//
+// Possible future work:
+//
+// * Don't download the entire heirarchy in one go (which
+//   might have been how V1 worked).  Implications for
+//   links (which may not have a valid target) and search
+//   which would then be missing data.
+//
+// * Review the download rate throttling.  Slow then fast?
+//   Detect bandwidth usage and speed up when it drops?
+//
+// * A lot of calls to notifyObservers().  It looks like
+//   these could be collapsed by maintaining a 'dirty'
+//   bit and there appears to be an attempt to do this.
+//   But it isn't used or is used in a limited fashion.
+//   Are there semanic issues requiring a call after certain
+//   updateItem() calls?
+//
+// * An error on a fetch could be due to one item in the batch.
+//   If the batch were broken up, perhaps more of the inventory
+//   would download.  (Handwave here, not certain this is an
+//   issue in practice.)
+//
+// * Conversion to AISv3.
+//
+
+
+namespace
+{
+
+///----------------------------------------------------------------------------
+/// Class <anonymous>::BGItemHttpHandler
+///----------------------------------------------------------------------------
+
+//
+// Http request handler class for single inventory item requests.
+//
+// We'll use a handler-per-request pattern here rather than
+// a shared handler.  Mainly convenient as this was converted
+// from a Responder class model.
+//
+// Derives from and is identical to the normal FetchItemHttpHandler
+// except that:  1) it uses the background request object which is
+// updated more slowly than the foreground and 2) keeps a count of
+// active requests on the LLInventoryModelBackgroundFetch object
+// to indicate outstanding operations are in-flight.
+//
+class BGItemHttpHandler : public LLInventoryModel::FetchItemHttpHandler
+{
+	LOG_CLASS(BGItemHttpHandler);
+	
+public:
+	BGItemHttpHandler(const LLSD & request_sd)
+		: LLInventoryModel::FetchItemHttpHandler(request_sd)
+		{
+			LLInventoryModelBackgroundFetch::instance().incrFetchCount(1);
+		}
+
+	virtual ~BGItemHttpHandler()
+		{
+			LLInventoryModelBackgroundFetch::instance().incrFetchCount(-1);
+		}
+
+protected:
+	BGItemHttpHandler(const BGItemHttpHandler &);				// Not defined
+	void operator=(const BGItemHttpHandler &);					// Not defined
+};
+
+
+///----------------------------------------------------------------------------
+/// Class <anonymous>::BGFolderHttpHandler
+///----------------------------------------------------------------------------
+
+// Http request handler class for folders.
+//
+// Handler for FetchInventoryDescendents2 and FetchLibDescendents2
+// caps requests for folders.
+//
+class BGFolderHttpHandler : public LLCore::HttpHandler
+{
+	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);
+		}
+	
+protected:
+	BGFolderHttpHandler(const BGFolderHttpHandler &);			// Not defined
+	void operator=(const BGFolderHttpHandler &);				// Not defined
+
+public:
+	virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);
+
+	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);
+
+private:
+	LLSD mRequestSD;
+	const uuid_vec_t mRecursiveCatUUIDs; // hack for storing away which cat fetches are recursive
+};
+
 
-const F32 MAX_TIME_FOR_SINGLE_FETCH = 10.f;
 const S32 MAX_FETCH_RETRIES = 10;
 
-LLInventoryModelBackgroundFetch::LLInventoryModelBackgroundFetch() :
+const char * const LOG_INV("Inventory");
+
+} // end of namespace anonymous
+
+
+///----------------------------------------------------------------------------
+/// Class LLInventoryModelBackgroundFetch
+///----------------------------------------------------------------------------
+
+LLInventoryModelBackgroundFetch::LLInventoryModelBackgroundFetch():
 	mBackgroundFetchActive(FALSE),
 	mFolderFetchActive(false),
+	mFetchCount(0),
 	mAllFoldersFetched(FALSE),
 	mRecursiveInventoryFetchStarted(FALSE),
 	mRecursiveLibraryFetchStarted(FALSE),
 	mNumFetchRetries(0),
 	mMinTimeBetweenFetches(0.3f),
 	mMaxTimeBetweenFetches(10.f),
-	mTimelyFetchPending(FALSE),
-	mFetchCount(0)
-{
-}
+	mTimelyFetchPending(FALSE)
+{}
 
 LLInventoryModelBackgroundFetch::~LLInventoryModelBackgroundFetch()
-{
-}
+{}
 
 bool LLInventoryModelBackgroundFetch::isBulkFetchProcessingComplete() const
 {
-	return mFetchQueue.empty() && mFetchCount<=0;
+	return mFetchQueue.empty() && mFetchCount <= 0;
 }
 
 bool LLInventoryModelBackgroundFetch::libraryFetchStarted() const
@@ -91,7 +240,7 @@ bool LLInventoryModelBackgroundFetch::inventoryFetchCompleted() const
 
 bool LLInventoryModelBackgroundFetch::inventoryFetchInProgress() const
 {
-	return inventoryFetchStarted() && !inventoryFetchCompleted();
+	return inventoryFetchStarted() && ! inventoryFetchCompleted();
 }
 
 bool LLInventoryModelBackgroundFetch::isEverythingFetched() const
@@ -104,24 +253,36 @@ BOOL LLInventoryModelBackgroundFetch::folderFetchActive() const
 	return mFolderFetchActive;
 }
 
+void LLInventoryModelBackgroundFetch::addRequestAtFront(const LLUUID & id, BOOL recursive, bool is_category)
+{
+	mFetchQueue.push_front(FetchQueueInfo(id, recursive, is_category));
+}
+
+void LLInventoryModelBackgroundFetch::addRequestAtBack(const LLUUID & id, BOOL recursive, bool is_category)
+{
+	mFetchQueue.push_back(FetchQueueInfo(id, recursive, is_category));
+}
+
 void LLInventoryModelBackgroundFetch::start(const LLUUID& id, BOOL recursive)
 {
-	LLViewerInventoryCategory* cat = gInventory.getCategory(id);
-	if (cat || (id.isNull() && !isEverythingFetched()))
-	{	// it's a folder, do a bulk fetch
-		LL_DEBUGS("InventoryFetch") << "Start fetching category: " << id << ", recursive: " << recursive << LL_ENDL;
+	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;
 
 		mBackgroundFetchActive = TRUE;
 		mFolderFetchActive = true;
 		if (id.isNull())
 		{
-			if (!mRecursiveInventoryFetchStarted)
+			if (! mRecursiveInventoryFetchStarted)
 			{
 				mRecursiveInventoryFetchStarted |= recursive;
 				mFetchQueue.push_back(FetchQueueInfo(gInventory.getRootFolderID(), recursive));
 				gIdleCallbacks.addFunction(&LLInventoryModelBackgroundFetch::backgroundFetchCB, NULL);
 			}
-			if (!mRecursiveLibraryFetchStarted)
+			if (! mRecursiveLibraryFetchStarted)
 			{
 				mRecursiveLibraryFetchStarted |= recursive;
 				mFetchQueue.push_back(FetchQueueInfo(gInventory.getLibraryRootFolderID(), recursive));
@@ -146,9 +307,9 @@ void LLInventoryModelBackgroundFetch::start(const LLUUID& id, BOOL recursive)
 			}
 		}
 	}
-	else if (LLViewerInventoryItem* itemp = gInventory.getItem(id))
+	else if (LLViewerInventoryItem * itemp = gInventory.getItem(id))
 	{
-		if (!itemp->mIsComplete && (mFetchQueue.empty() || mFetchQueue.front().mUUID != id))
+		if (! itemp->mIsComplete && (mFetchQueue.empty() || mFetchQueue.front().mUUID != id))
 		{
 			mBackgroundFetchActive = TRUE;
 
@@ -172,11 +333,12 @@ void LLInventoryModelBackgroundFetch::setAllFoldersFetched()
 		mRecursiveLibraryFetchStarted)
 	{
 		mAllFoldersFetched = TRUE;
-		//LL_INFOS() << "All folders fetched, validating" << LL_ENDL;
+		//LL_INFOS(LOG_INV) << "All folders fetched, validating" << LL_ENDL;
 		//gInventory.validate();
 	}
 	mFolderFetchActive = false;
 	mBackgroundFetchActive = false;
+	LL_INFOS(LOG_INV) << "Inventory background fetch completed" << LL_ENDL;
 }
 
 void LLInventoryModelBackgroundFetch::backgroundFetchCB(void *)
@@ -203,12 +365,7 @@ void LLInventoryModelBackgroundFetch::backgroundFetch()
 		// No more categories to fetch, stop fetch process.
 		if (mFetchQueue.empty())
 		{
-			LL_INFOS() << "Inventory fetch completed" << LL_ENDL;
-
 			setAllFoldersFetched();
-			mBackgroundFetchActive = false;
-			mFolderFetchActive = false;
-
 			return;
 		}
 
@@ -219,7 +376,7 @@ void LLInventoryModelBackgroundFetch::backgroundFetch()
 			// Double timeouts on failure.
 			mMinTimeBetweenFetches = llmin(mMinTimeBetweenFetches * 2.f, 10.f);
 			mMaxTimeBetweenFetches = llmin(mMaxTimeBetweenFetches * 2.f, 120.f);
-			LL_DEBUGS() << "Inventory fetch times grown to (" << mMinTimeBetweenFetches << ", " << mMaxTimeBetweenFetches << ")" << LL_ENDL;
+			LL_DEBUGS(LOG_INV) << "Inventory fetch times grown to (" << mMinTimeBetweenFetches << ", " << mMaxTimeBetweenFetches << ")" << LL_ENDL;
 			// fetch is no longer considered "timely" although we will wait for full time-out.
 			mTimelyFetchPending = FALSE;
 		}
@@ -231,7 +388,7 @@ void LLInventoryModelBackgroundFetch::backgroundFetch()
 				break;
 			}
 
-			if(gDisconnected)
+			if (gDisconnected)
 			{
 				// Just bail if we are disconnected.
 				break;
@@ -292,7 +449,7 @@ void LLInventoryModelBackgroundFetch::backgroundFetch()
 						// Shrink timeouts based on success.
 						mMinTimeBetweenFetches = llmax(mMinTimeBetweenFetches * 0.8f, 0.3f);
 						mMaxTimeBetweenFetches = llmax(mMaxTimeBetweenFetches * 0.8f, 10.f);
-						LL_DEBUGS() << "Inventory fetch times shrunk to (" << mMinTimeBetweenFetches << ", " << mMaxTimeBetweenFetches << ")" << LL_ENDL;
+						LL_DEBUGS(LOG_INV) << "Inventory fetch times shrunk to (" << mMinTimeBetweenFetches << ", " << mMaxTimeBetweenFetches << ")" << LL_ENDL;
 					}
 
 					mTimelyFetchPending = FALSE;
@@ -355,258 +512,61 @@ void LLInventoryModelBackgroundFetch::backgroundFetch()
 	}
 }
 
-void LLInventoryModelBackgroundFetch::incrFetchCount(S16 fetching) 
+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; 
 	}
 }
 
-class LLInventoryModelFetchItemResponder : public LLInventoryModel::fetchInventoryResponder
-{
-	LOG_CLASS(LLInventoryModelFetchItemResponder);
-public:
-	LLInventoryModelFetchItemResponder(const LLSD& request_sd) :
-		LLInventoryModel::fetchInventoryResponder(request_sd)
-	{
-		LLInventoryModelBackgroundFetch::instance().incrFetchCount(1);
-	}
-private:
-	/* virtual */ void httpCompleted()
-	{
-		LLInventoryModelBackgroundFetch::instance().incrFetchCount(-1);
-		LLInventoryModel::fetchInventoryResponder::httpCompleted();
-	}
-};
-
-class LLInventoryModelFetchDescendentsResponder: public LLHTTPClient::Responder
-{
-	LOG_CLASS(LLInventoryModelFetchDescendentsResponder);
-public:
-	LLInventoryModelFetchDescendentsResponder(const LLSD& request_sd, uuid_vec_t recursive_cats) : 
-		mRequestSD(request_sd),
-		mRecursiveCatUUIDs(recursive_cats)
-	{
-		LLInventoryModelBackgroundFetch::instance().incrFetchCount(1);
-	}
-	//LLInventoryModelFetchDescendentsResponder() {};
-private:
-	/* virtual */ void httpCompleted()
-	{
-		LLInventoryModelBackgroundFetch::instance().incrFetchCount(-1);
-		LLHTTPClient::Responder::httpCompleted();
-	}
-	/* virtual */ void httpSuccess();
-	/* virtual */ void httpFailure();
-protected:
-	BOOL getIsRecursive(const LLUUID& cat_id) const;
-private:
-	LLSD mRequestSD;
-	uuid_vec_t mRecursiveCatUUIDs; // hack for storing away which cat fetches are recursive
-};
-
-// If we get back a normal response, handle it here.
-void LLInventoryModelFetchDescendentsResponder::httpSuccess()
+// Bundle up a bunch of requests to send all at once.
+void LLInventoryModelBackgroundFetch::bulkFetch()
 {
-	const LLSD& content = getContent();
-	if (!content.isMap())
+	//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)
 	{
-		failureResult(HTTP_INTERNAL_ERROR, "Malformed response contents", content);
 		return;
 	}
-	LLInventoryModelBackgroundFetch *fetcher = LLInventoryModelBackgroundFetch::getInstance();
-	if (content.has("folders"))	
-	{
-
-		for(LLSD::array_const_iterator folder_it = content["folders"].beginArray();
-			folder_it != content["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() << "Got a UpdateInventoryItem for the wrong agent."
-			//			<< LL_ENDL;
-			//	break;
-			//}
-
-			LLUUID parent_id = folder_sd["folder_id"];
-			LLUUID owner_id = folder_sd["owner_id"];
-			S32    version  = (S32)folder_sd["version"].asInteger();
-			S32    descendents = (S32)folder_sd["descendents"].asInteger();
-			LLPointer<LLViewerInventoryCategory> tcategory = new LLViewerInventoryCategory(owner_id);
 
-            if (parent_id.isNull())
-            {
-			    LLPointer<LLViewerInventoryItem> titem = new LLViewerInventoryItem;
-			    for(LLSD::array_const_iterator item_it = folder_sd["items"].beginArray();
-				    item_it != folder_sd["items"].endArray();
-				    ++item_it)
-			    {	
-                    const LLUUID lost_uuid = gInventory.findCategoryUUIDForType(LLFolderType::FT_LOST_AND_FOUND);
-                    if (lost_uuid.notNull())
-                    {
-				        LLSD item = *item_it;
-				        titem->unpackMessage(item);
-				
-                        LLInventoryModel::update_list_t update;
-                        LLInventoryModel::LLCategoryUpdate new_folder(lost_uuid, 1);
-                        update.push_back(new_folder);
-                        gInventory.accountForUpdate(update);
-
-                        titem->setParent(lost_uuid);
-                        titem->updateParentOnServer(FALSE);
-                        gInventory.updateItem(titem);
-                        gInventory.notifyObservers();
-                        
-                    }
-                }
-            }
-
-	        LLViewerInventoryCategory* pcat = gInventory.getCategory(parent_id);
-			if (!pcat)
-			{
-				continue;
-			}
-
-			for(LLSD::array_const_iterator category_it = folder_sd["categories"].beginArray();
-				category_it != folder_sd["categories"].endArray();
-				++category_it)
-			{	
-				LLSD category = *category_it;
-				tcategory->fromLLSD(category); 
-				
-				const BOOL recursive = getIsRecursive(tcategory->getUUID());
-				
-				if (recursive)
-				{
-					fetcher->mFetchQueue.push_back(LLInventoryModelBackgroundFetch::FetchQueueInfo(tcategory->getUUID(), recursive));
-				}
-				else if ( !gInventory.isCategoryComplete(tcategory->getUUID()) )
-				{
-					gInventory.updateCategory(tcategory);
-				}
-
-			}
-			LLPointer<LLViewerInventoryItem> titem = new LLViewerInventoryItem;
-			for(LLSD::array_const_iterator item_it = folder_sd["items"].beginArray();
-				item_it != folder_sd["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"))
-	{
-		for(LLSD::array_const_iterator folder_it = content["bad_folders"].beginArray();
-			folder_it != content["bad_folders"].endArray();
-			++folder_it)
-		{
-			// *TODO: Stop copying data
-			LLSD folder_sd = *folder_it;
-			
-			// These folders failed on the dataserver.  We probably don't want to retry them.
-			LL_WARNS() << "Folder " << folder_sd["folder_id"].asString() 
-					   << "Error: " << folder_sd["error"].asString() << LL_ENDL;
-		}
-	}
+	// *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
+	static const F32 new_min_time(0.05f);		// *HACK:  Clean this up when old code goes away entirely.
 	
-	if (fetcher->isBulkFetchProcessingComplete())
+	mMinTimeBetweenFetches = new_min_time;
+	if (mMinTimeBetweenFetches < new_min_time) 
 	{
-		LL_INFOS() << "Inventory fetch completed" << LL_ENDL;
-		fetcher->setAllFoldersFetched();
+		mMinTimeBetweenFetches = new_min_time;  // *HACK:  See above.
 	}
-	
-	gInventory.notifyObservers();
-}
-
-// If we get back an error (not found, etc...), handle it here.
-void LLInventoryModelFetchDescendentsResponder::httpFailure()
-{
-	LL_WARNS() << dumpResponse() << LL_ENDL;
-	LLInventoryModelBackgroundFetch *fetcher = LLInventoryModelBackgroundFetch::getInstance();
 
-	LL_INFOS() << dumpResponse() << LL_ENDL;
-						
-	fetcher->incrFetchCount(-1);
-
-	if (getStatus()==HTTP_INTERNAL_ERROR) // 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"];
-			const BOOL recursive = getIsRecursive(folder_id);
-			fetcher->mFetchQueue.push_front(LLInventoryModelBackgroundFetch::FetchQueueInfo(folder_id, recursive));
-		}
-	}
-	else
+	if (mFetchCount)
 	{
-		if (fetcher->isBulkFetchProcessingComplete())
-		{
-			fetcher->setAllFoldersFetched();
-		}
-	}
-	gInventory.notifyObservers();
-}
-
-BOOL LLInventoryModelFetchDescendentsResponder::getIsRecursive(const LLUUID& cat_id) const
-{
-	return (std::find(mRecursiveCatUUIDs.begin(),mRecursiveCatUUIDs.end(), cat_id) != mRecursiveCatUUIDs.end());
-}
-// Bundle up a bunch of requests to send all at once.
-// static   
-void LLInventoryModelBackgroundFetch::bulkFetch()
-{
-	//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) return;
-
-	S16 max_concurrent_fetches=8;
-	F32 new_min_time = 0.5f;			//HACK!  Clean this up when old code goes away entirely.
-	if (mMinTimeBetweenFetches < new_min_time) 
-	{
-		mMinTimeBetweenFetches=new_min_time;  //HACK!  See above.
+		// Process completed background HTTP requests
+		gInventory.handleResponses(false);
 	}
 	
-	if (gDisconnected ||
-		(mFetchCount > max_concurrent_fetches) ||
+	if ((mFetchCount > max_concurrent_fetches) ||
 		(mFetchTimer.getElapsedTimeF32() < mMinTimeBetweenFetches))
 	{
-		return; // just bail if we are disconnected
+		return;
 	}
 
-	U32 item_count=0;
-	U32 folder_count=0;
-	U32 max_batch_size=5;
+	U32 item_count(0);
+	U32 folder_count(0);
 
-	U32 sort_order = gSavedSettings.getU32(LLInventoryPanel::DEFAULT_SORT_ORDER) & 0x1;
+	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;
 
 	LLSD folder_request_body;
@@ -614,27 +574,27 @@ void LLInventoryModelBackgroundFetch::bulkFetch()
 	LLSD item_request_body;
 	LLSD item_request_body_lib;
 
-	while (!mFetchQueue.empty() 
+	while (! mFetchQueue.empty() 
 			&& (item_count + folder_count) < max_batch_size)
 	{
-		const FetchQueueInfo& fetch_info = mFetchQueue.front();
+		const FetchQueueInfo & fetch_info(mFetchQueue.front());
 		if (fetch_info.mIsCategory)
 		{
-			const LLUUID &cat_id = fetch_info.mUUID;
+			const LLUUID & cat_id(fetch_info.mUUID);
 			if (cat_id.isNull()) //DEV-17797
 			{
 				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_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);
+				const LLViewerInventoryCategory * cat(gInventory.getCategory(cat_id));
 		
 				if (cat)
 				{
@@ -643,21 +603,26 @@ void LLInventoryModelBackgroundFetch::bulkFetch()
 						LLSD folder_sd;
 						folder_sd["folder_id"]		= cat->getUUID();
 						folder_sd["owner_id"]		= cat->getOwnerID();
-						folder_sd["sort_order"]		= (LLSD::Integer)sort_order;
-						folder_sd["fetch_folders"]	= TRUE; //(LLSD::Boolean)sFullFetchStarted;
-						folder_sd["fetch_items"]	= (LLSD::Boolean)TRUE;
+						folder_sd["sort_order"]		= LLSD::Integer(sort_order);
+						folder_sd["fetch_folders"]	= LLSD::Boolean(TRUE); //(LLSD::Boolean)sFullFetchStarted;
+						folder_sd["fetch_items"]	= LLSD::Boolean(TRUE);
 				    
 						if (ALEXANDRIA_LINDEN_ID == cat->getOwnerID())
+						{
 							folder_request_body_lib["folders"].append(folder_sd);
+						}
 						else
+						{
 							folder_request_body["folders"].append(folder_sd);
+						}
 						folder_count++;
 					}
+
 					// May already have this folder, but append child folders to list.
 					if (fetch_info.mRecursive)
 					{	
-						LLInventoryModel::cat_array_t* categories;
-						LLInventoryModel::item_array_t* items;
+						LLInventoryModel::cat_array_t * categories(NULL);
+						LLInventoryModel::item_array_t * items(NULL);
 						gInventory.getDirectDescendentsOf(cat->getUUID(), categories, items);
 						for (LLInventoryModel::cat_array_t::const_iterator it = categories->begin();
 							 it != categories->end();
@@ -669,11 +634,14 @@ void LLInventoryModelBackgroundFetch::bulkFetch()
 				}
 			}
 			if (fetch_info.mRecursive)
+			{
 				recursive_cats.push_back(cat_id);
+			}
 		}
 		else
 		{
-			LLViewerInventoryItem* itemp = gInventory.getItem(fetch_info.mUUID);
+			LLViewerInventoryItem * itemp(gInventory.getItem(fetch_info.mUUID));
+
 			if (itemp)
 			{
 				LLSD item_sd;
@@ -694,72 +662,80 @@ void LLInventoryModelBackgroundFetch::bulkFetch()
 
 		mFetchQueue.pop_front();
 	}
-		
+
+	// Issue HTTP POST requests to fetch folders and items
+	
 	if (item_count + folder_count > 0)
 	{
 		if (folder_count)
 		{
-			std::string url = region->getCapability("FetchInventoryDescendents2");   			
-			if ( !url.empty() )
+			if (folder_request_body["folders"].size())
 			{
-				if (folder_request_body["folders"].size())
+				const std::string url(region->getCapability("FetchInventoryDescendents2"));
+
+				if (! url.empty())
 				{
-					LLInventoryModelFetchDescendentsResponder *fetcher = new LLInventoryModelFetchDescendentsResponder(folder_request_body, recursive_cats);
-					LLHTTPClient::post(url, folder_request_body, fetcher, 300.0);
+					BGFolderHttpHandler * 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())
-				{
-					std::string url_lib = gAgent.getRegion()->getCapability("FetchLibDescendents2");
+			}
+			
+			if (folder_request_body_lib["folders"].size())
+			{
+				const std::string url(region->getCapability("FetchLibDescendents2"));
 
-					LLInventoryModelFetchDescendentsResponder *fetcher = new LLInventoryModelFetchDescendentsResponder(folder_request_body_lib, recursive_cats);
-					LLHTTPClient::post(url_lib, folder_request_body_lib, fetcher, 300.0);
+				if (! url.empty())
+				{
+					BGFolderHttpHandler * 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)
 		{
-			std::string url;
-
 			if (item_request_body.size())
 			{
-				url = region->getCapability("FetchInventory2");
-				if (!url.empty())
+				const std::string url(region->getCapability("FetchInventory2"));
+
+				if (! url.empty())
 				{
 					LLSD body;
 					body["items"] = item_request_body;
-
-					LLHTTPClient::post(url, body, new LLInventoryModelFetchItemResponder(body));
+					BGItemHttpHandler * 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"));
 
-				url = region->getCapability("FetchLib2");
-				if (!url.empty())
+				if (! url.empty())
 				{
 					LLSD body;
 					body["items"] = item_request_body_lib;
-
-					LLHTTPClient::post(url, body, new LLInventoryModelFetchItemResponder(body));
+					BGItemHttpHandler * handler(new BGItemHttpHandler(body));
+					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
+bool LLInventoryModelBackgroundFetch::fetchQueueContainsNoDescendentsOf(const LLUUID & cat_id) const
 {
 	for (fetch_queue_t::const_iterator it = mFetchQueue.begin();
-		 it != mFetchQueue.end(); ++it)
+		 it != mFetchQueue.end();
+		 ++it)
 	{
-		const LLUUID& fetch_id = (*it).mUUID;
+		const LLUUID & fetch_id = (*it).mUUID;
 		if (gInventory.isObjectDescendentOf(fetch_id, cat_id))
 			return false;
 	}
@@ -767,3 +743,304 @@ bool LLInventoryModelBackgroundFetch::fetchQueueContainsNoDescendentsOf(const LL
 }
 
 
+namespace
+{
+
+///----------------------------------------------------------------------------
+/// Class <anonymous>::BGFolderHttpHandler
+///----------------------------------------------------------------------------
+
+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);
+
+	// Must delete on completion.
+	delete this;
+}
+
+
+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);
+
+            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)
+			    {	
+                    const LLUUID lost_uuid(gInventory.findCategoryUUIDForType(LLFolderType::FT_LOST_AND_FOUND));
+
+                    if (lost_uuid.notNull())
+                    {
+				        LLSD item(*item_it);
+
+				        titem->unpackMessage(item);
+				
+                        LLInventoryModel::update_list_t update;
+                        LLInventoryModel::LLCategoryUpdate new_folder(lost_uuid, 1);
+                        update.push_back(new_folder);
+                        gInventory.accountForUpdate(update);
+
+                        titem->setParent(lost_uuid);
+                        titem->updateParentOnServer(FALSE);
+                        gInventory.updateItem(titem);
+                        gInventory.notifyObservers();
+                    }
+                }
+            }
+
+	        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();
+	}
+	
+	gInventory.notifyObservers();
+}
+
+
+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;
+
+	// Could use a 404 test here to try to detect revoked caps...
+	
+	// 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();
+		}
+	}
+	gInventory.notifyObservers();
+}
+
+
+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();
+		}
+	}
+	gInventory.notifyObservers();
+}
+
+
+bool BGFolderHttpHandler::getIsRecursive(const LLUUID & cat_id) const
+{
+	return std::find(mRecursiveCatUUIDs.begin(), mRecursiveCatUUIDs.end(), cat_id) != mRecursiveCatUUIDs.end();
+}
+
+///----------------------------------------------------------------------------
+/// Class <anonymous>::BGItemHttpHandler
+///----------------------------------------------------------------------------
+
+// Nothing to implement here.  All ctor/dtor changes.
+
+} // end namespace anonymous