From 8fc350125c671baeae6b7f8b1814251009f4f50a Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Wed, 23 May 2012 19:12:09 -0400
Subject: Integrate llcorehttp library into lltexturefetch design. This is the
 first functional viewer pass with the HTTP work of the texture fetch code
 performed by the llcorehttp library.  Not exactly a 'drop-in' replacement but
 a work-alike with some changes (e.g. handler notification in consumer thread
 versus responder notification in worker thread).

This also includes some temporary changes in the priority scheme to prevent
the kind of priority inversion found in VWR-28996.  Scheme used here does
provide liveness if not optimal responsiveness or order-of-operation.

The llcorehttp library at this point is far from optimally performing.
Its worker thread is making relatively poor use of cycles it gets and
it doesn't idle or sleep intelligently yet.  This early integration step
helps shake out the interfaces, implementation niceties will be covered
soon.
---
 indra/newview/llappviewer.cpp | 159 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 159 insertions(+)

(limited to 'indra/newview/llappviewer.cpp')

diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 1174d108d2..8e6deb9cce 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -212,6 +212,11 @@
 #include "llmachineid.h"
 #include "llmainlooprepeater.h"
 
+// LLCore::HTTP
+#include "httpcommon.h"
+#include "httprequest.h"
+#include "httphandler.h"
+
 // *FIX: These extern globals should be cleaned up.
 // The globals either represent state/config/resource-storage of either 
 // this app, or another 'component' of the viewer. App globals should be 
@@ -326,6 +331,53 @@ static std::string gLaunchFileOnQuit;
 // Used on Win32 for other apps to identify our window (eg, win_setup)
 const char* const VIEWER_WINDOW_CLASSNAME = "Second Life";
 
+namespace
+{
+
+// This class manages the lifecyle of the core http library.
+// Slightly different style than traditional code but reflects
+// the use of handler classes and light-weight interface
+// object instances of the new libraries.  To be used
+// as a singleton and static construction is fine.
+class CoreHttp : public LLCore::HttpHandler
+{
+public:
+	CoreHttp();
+	~CoreHttp();
+	
+	// Initialize the LLCore::HTTP library creating service classes
+	// and starting the servicing thread.  Caller is expected to do
+	// other initializations (SSL mutex, thread hash function) appropriate
+	// for the application.
+	void init();
+
+	// Request that the servicing thread stop servicing requests,
+	// release resource references and stop.
+	void requestStop();
+	
+	// Terminate LLCore::HTTP library services.  Caller is expected
+	// to have made a best-effort to shutdown the servicing thread
+	// by issuing a requestThreadStop() and waiting for completion
+	// notification that the stop has completed.
+	void cleanup();
+
+	// Notification when the stop request is complete.
+	virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);
+
+private:
+	static const F64			MAX_THREAD_WAIT_TIME;
+	
+private:
+	LLCore::HttpRequest *		mRequest;
+	LLCore::HttpHandle			mStopHandle;
+	F64							mStopRequested;
+	bool						mStopped;
+};
+
+CoreHttp coreHttpLib;
+	
+}  // end anonymous namespace
+
 //-- LLDeferredTaskList ------------------------------------------------------
 
 /**
@@ -720,6 +772,9 @@ bool LLAppViewer::init()
 	LLViewerStatsRecorder::initClass();
 #endif
 
+	// Initialize the non-LLCurl libcurl library
+	coreHttpLib.init();
+	
     // *NOTE:Mani - LLCurl::initClass is not thread safe. 
     // Called before threads are created.
     LLCurl::initClass(gSavedSettings.getF32("CurlRequestTimeOut"), 
@@ -1807,6 +1862,7 @@ bool LLAppViewer::cleanup()
 
 	// Delete workers first
 	// shotdown all worker threads before deleting them in case of co-dependencies
+	coreHttpLib.requestStop();
 	sTextureFetch->shutdown();
 	sTextureCache->shutdown();	
 	sImageDecodeThread->shutdown();
@@ -1890,6 +1946,9 @@ bool LLAppViewer::cleanup()
 	// *NOTE:Mani - The following call is not thread safe. 
 	LLCurl::cleanupClass();
 
+	// Non-LLCurl libcurl library
+	coreHttpLib.cleanup();
+
 	// If we're exiting to launch an URL, do that here so the screen
 	// is at the right resolution before we launch IE.
 	if (!gLaunchFileOnQuit.empty())
@@ -5267,3 +5326,103 @@ void LLAppViewer::metricsSend(bool enable_reporting)
 	gViewerAssetStatsMain->reset();
 }
 
+namespace
+{
+
+const F64 CoreHttp::MAX_THREAD_WAIT_TIME(10.0);
+
+CoreHttp::CoreHttp()
+	: mRequest(NULL),
+	  mStopHandle(LLCORE_HTTP_HANDLE_INVALID),
+	  mStopRequested(0.0),
+	  mStopped(false)
+{}
+
+
+CoreHttp::~CoreHttp()
+{
+	delete mRequest;
+	mRequest = NULL;
+}
+
+
+void CoreHttp::init()
+{
+	LLCore::HttpStatus status = LLCore::HttpRequest::createService();
+	if (! status)
+	{
+		LL_ERRS("Init") << "Failed to initialize HTTP services.  Reason:  "
+						<< status.toString()
+						<< LL_ENDL;
+	}
+
+	status = LLCore::HttpRequest::startThread();
+	if (! status)
+	{
+		LL_ERRS("Init") << "Failed to start HTTP servicing thread.  Reason:  "
+						<< status.toString()
+						<< LL_ENDL;
+	}
+
+	mRequest = new LLCore::HttpRequest;
+}
+
+
+void CoreHttp::requestStop()
+{
+	llassert_always(mRequest);
+
+	mStopHandle = mRequest->requestStopThread(this);
+	if (LLCORE_HTTP_HANDLE_INVALID != mStopHandle)
+	{
+		mStopRequested = LLTimer::getTotalSeconds();
+	}
+}
+
+
+void CoreHttp::cleanup()
+{
+	if (LLCORE_HTTP_HANDLE_INVALID == mStopHandle)
+	{
+		// Should have been started already...
+		requestStop();
+	}
+	
+	if (LLCORE_HTTP_HANDLE_INVALID == mStopHandle)
+	{
+		LL_WARNS("Cleanup") << "Attempting to cleanup HTTP services without thread shutdown"
+							<< LL_ENDL;
+	}
+	else
+	{
+		while (! mStopped && LLTimer::getTotalSeconds() < (mStopRequested + MAX_THREAD_WAIT_TIME))
+		{
+			mRequest->update(200);
+			ms_sleep(50);
+		}
+		if (! mStopped)
+		{
+			LL_WARNS("Cleanup") << "Attempting to cleanup HTTP services with thread shutdown incomplete"
+								<< LL_ENDL;
+		}
+	}
+
+	delete mRequest;
+	mRequest = NULL;
+
+	LLCore::HttpStatus status = LLCore::HttpRequest::destroyService();
+	if (! status)
+	{
+		LL_WARNS("Cleanup") << "Failed to shutdown HTTP services, continuing.  Reason:  "
+							<< status.toString()
+							<< LL_ENDL;
+	}
+}
+
+
+void CoreHttp::onCompleted(LLCore::HttpHandle, LLCore::HttpResponse *)
+{
+	mStopped = true;
+}
+
+}  // end anonymous namespace
-- 
cgit v1.3


From 05af16a23abe37210e0b880aa27387d8994419dd Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Wed, 6 Jun 2012 13:52:38 -0400
Subject: Policy + caching fixes + https support + POST working Implemented
 first global policy definitions to support SSL CA certificate configuration
 to support https: operations.  Fixed HTTP 206 status handling to match what
 is currently being done by grid services and to lay a foundation for fixes
 that will be a response to ER-1824.  More libcurl CURLOPT options set on easy
 handles to do peer verification in the traditional way.  HTTP POST working
 and now reporting asset metrics back to grid for the viewer's asset system. 
 This uses LLSD so that is also showing as compatible with the new library.

---
 indra/llcorehttp/CMakeLists.txt     |  2 ++
 indra/llcorehttp/_httplibcurl.cpp   |  1 +
 indra/llcorehttp/_httpoprequest.cpp | 45 ++++++++++++++++++++++++++++++++-----
 indra/llcorehttp/_httppolicy.cpp    |  4 ++--
 indra/llcorehttp/_httppolicy.h      | 10 +++++++++
 indra/llcorehttp/_httpservice.h     |  8 +++----
 indra/llcorehttp/httpcommon.cpp     |  5 ++++-
 indra/llcorehttp/httpcommon.h       | 11 ++++++++-
 indra/llcorehttp/httprequest.cpp    | 13 +++++++++--
 indra/llcorehttp/httprequest.h      | 16 +++++++------
 indra/newview/llappviewer.cpp       | 12 +++++++++-
 indra/newview/lltexturefetch.cpp    | 37 +++++++++++++++++-------------
 12 files changed, 126 insertions(+), 38 deletions(-)

(limited to 'indra/newview/llappviewer.cpp')

diff --git a/indra/llcorehttp/CMakeLists.txt b/indra/llcorehttp/CMakeLists.txt
index 9a073eb850..3fda524ddf 100644
--- a/indra/llcorehttp/CMakeLists.txt
+++ b/indra/llcorehttp/CMakeLists.txt
@@ -33,6 +33,7 @@ set(llcorehttp_SOURCE_FILES
     _httpoprequest.cpp
     _httpopsetpriority.cpp
     _httppolicy.cpp
+    _httppolicyglobal.cpp
     _httpreplyqueue.cpp
     _httprequestqueue.cpp
     _httpservice.cpp
@@ -55,6 +56,7 @@ set(llcorehttp_HEADER_FILES
     _httpoprequest.h
     _httpopsetpriority.h
     _httppolicy.h
+    _httppolicyglobal.h
     _httpreadyqueue.h
     _httpreplyqueue.h
     _httprequestqueue.h
diff --git a/indra/llcorehttp/_httplibcurl.cpp b/indra/llcorehttp/_httplibcurl.cpp
index 704f9baac9..5272c391e8 100644
--- a/indra/llcorehttp/_httplibcurl.cpp
+++ b/indra/llcorehttp/_httplibcurl.cpp
@@ -27,6 +27,7 @@
 #include "_httplibcurl.h"
 
 #include "httpheaders.h"
+#include "bufferarray.h"
 #include "_httpoprequest.h"
 
 
diff --git a/indra/llcorehttp/_httpoprequest.cpp b/indra/llcorehttp/_httpoprequest.cpp
index f52ff5a44c..4bdc4a5257 100644
--- a/indra/llcorehttp/_httpoprequest.cpp
+++ b/indra/llcorehttp/_httpoprequest.cpp
@@ -40,8 +40,10 @@
 #include "_httpreplyqueue.h"
 #include "_httpservice.h"
 #include "_httppolicy.h"
+#include "_httppolicyglobal.h"
 #include "_httplibcurl.h"
 
+#include "llhttpstatuscodes.h"
 
 namespace
 {
@@ -153,14 +155,14 @@ HttpOpRequest::~HttpOpRequest()
 void HttpOpRequest::stageFromRequest(HttpService * service)
 {
 	addRef();
-	service->getPolicy()->addOp(this);			// transfers refcount
+	service->getPolicy().addOp(this);			// transfers refcount
 }
 
 
 void HttpOpRequest::stageFromReady(HttpService * service)
 {
 	addRef();
-	service->getTransport()->addOp(this);		// transfers refcount
+	service->getTransport().addOp(this);		// transfers refcount
 }
 
 
@@ -195,6 +197,8 @@ void HttpOpRequest::stageFromActive(HttpService * service)
 
 void HttpOpRequest::visitNotifier(HttpRequest * request)
 {
+	static const HttpStatus partial_content(HTTP_PARTIAL_CONTENT, HE_SUCCESS);
+	
 	if (mLibraryHandler)
 	{
 		HttpResponse * response = new HttpResponse();
@@ -208,9 +212,15 @@ void HttpOpRequest::visitNotifier(HttpRequest * request)
 			offset = mReplyOffset;
 			length = mReplyLength;
 		}
-		else if (mReplyBody)
+		else if (mReplyBody && partial_content == mStatus)
 		{
-			// Provide implicit offset/length from request/response
+			// Legacy grid services did not provide a 'Content-Range'
+			// header in responses to full- or partly-satisfyiable
+			// 'Range' requests.  For these, we have to hope that
+			// the data starts where requested and the length is simply
+			// whatever we received.  A bit of sanity could be provided
+			// by overlapping ranged requests and verifying that the
+			// overlap matches.
 			offset = mReqOffset;
 			length = mReplyBody->size();
 		}
@@ -306,6 +316,9 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 	// *FIXME:  better error handling later
 	HttpStatus status;
 
+	// Get policy options
+	HttpPolicyGlobal & policy(service->getPolicy().getGlobalOptions());
+	
 	mCurlHandle = curl_easy_init();
 	// curl_easy_setopt(mCurlHandle, CURLOPT_VERBOSE, 1);
 	curl_easy_setopt(mCurlHandle, CURLOPT_TIMEOUT, 30);
@@ -322,21 +335,40 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 	curl_easy_setopt(mCurlHandle, CURLOPT_DNS_CACHE_TIMEOUT, 0);
 	curl_easy_setopt(mCurlHandle, CURLOPT_AUTOREFERER, 1);
 	curl_easy_setopt(mCurlHandle, CURLOPT_FOLLOWLOCATION, 1);
-	curl_easy_setopt(mCurlHandle, CURLOPT_MAXREDIRS, 10);
+	curl_easy_setopt(mCurlHandle, CURLOPT_MAXREDIRS, 10);		// *FIXME:  parameterize this later
 	curl_easy_setopt(mCurlHandle, CURLOPT_WRITEFUNCTION, writeCallback);
 	curl_easy_setopt(mCurlHandle, CURLOPT_WRITEDATA, mCurlHandle);
 	curl_easy_setopt(mCurlHandle, CURLOPT_READFUNCTION, readCallback);
 	curl_easy_setopt(mCurlHandle, CURLOPT_READDATA, mCurlHandle);
+	curl_easy_setopt(mCurlHandle, CURLOPT_SSL_VERIFYPEER, 1);
+	curl_easy_setopt(mCurlHandle, CURLOPT_SSL_VERIFYHOST, 0);
 
+	std::string opt_value;
+	if (policy.get(HttpRequest::GP_CA_PATH, opt_value))
+	{
+		curl_easy_setopt(mCurlHandle, CURLOPT_CAPATH, opt_value.c_str());
+	}
+	if (policy.get(HttpRequest::GP_CA_FILE, opt_value))
+	{
+		curl_easy_setopt(mCurlHandle, CURLOPT_CAINFO, opt_value.c_str());
+	}
+	if (policy.get(HttpRequest::GP_HTTP_PROXY, opt_value))
+	{
+		curl_easy_setopt(mCurlHandle, CURLOPT_PROXY, opt_value.c_str());
+	}
+	
 	switch (mReqMethod)
 	{
 	case HOR_GET:
 		curl_easy_setopt(mCurlHandle, CURLOPT_HTTPGET, 1);
+		mCurlHeaders = curl_slist_append(mCurlHeaders, "Connection: keep-alive");
+		mCurlHeaders = curl_slist_append(mCurlHeaders, "Keep-alive: 300");
 		break;
 		
 	case HOR_POST:
 		{
 			curl_easy_setopt(mCurlHandle, CURLOPT_POST, 1);
+			curl_easy_setopt(mCurlHandle, CURLOPT_ENCODING, "");
 			long data_size(0);
 			if (mReqBody)
 			{
@@ -358,8 +390,11 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 				data_size = mReqBody->size();
 			}
 			curl_easy_setopt(mCurlHandle, CURLOPT_INFILESIZE, data_size);
+			curl_easy_setopt(mCurlHandle, CURLOPT_POSTFIELDS, (void *) NULL);
 			mCurlHeaders = curl_slist_append(mCurlHeaders, "Transfer-Encoding: chunked");
 			mCurlHeaders = curl_slist_append(mCurlHeaders, "Expect:");
+			mCurlHeaders = curl_slist_append(mCurlHeaders, "Connection: keep-alive");
+			mCurlHeaders = curl_slist_append(mCurlHeaders, "Keep-alive: 300");
 		}
 		break;
 		
diff --git a/indra/llcorehttp/_httppolicy.cpp b/indra/llcorehttp/_httppolicy.cpp
index 1d28f23d56..51f5e487dc 100644
--- a/indra/llcorehttp/_httppolicy.cpp
+++ b/indra/llcorehttp/_httppolicy.cpp
@@ -76,12 +76,12 @@ void HttpPolicy::addOp(HttpOpRequest * op)
 HttpService::ELoopSpeed HttpPolicy::processReadyQueue()
 {
 	HttpService::ELoopSpeed result(HttpService::REQUEST_SLEEP);
-	HttpLibcurl * pTransport(mService->getTransport());
+	HttpLibcurl & transport(mService->getTransport());
 	
 	for (int policy_class(0); policy_class < HttpRequest::POLICY_CLASS_LIMIT; ++policy_class)
 	{
 		HttpReadyQueue & readyq(mReadyQueue[policy_class]);
-		int active(pTransport->getActiveCountInClass(policy_class));
+		int active(transport.getActiveCountInClass(policy_class));
 		int needed(8 - active);
 
 		if (needed > 0 && mReadyInClass[policy_class] > 0)
diff --git a/indra/llcorehttp/_httppolicy.h b/indra/llcorehttp/_httppolicy.h
index 2bc03c531f..425079ec63 100644
--- a/indra/llcorehttp/_httppolicy.h
+++ b/indra/llcorehttp/_httppolicy.h
@@ -31,6 +31,7 @@
 #include "httprequest.h"
 #include "_httpservice.h"
 #include "_httpreadyqueue.h"
+#include "_httppolicyglobal.h"
 
 
 namespace LLCore
@@ -68,11 +69,20 @@ public:
 
 	// Shadows HttpService's method
 	bool changePriority(HttpHandle handle, HttpRequest::priority_t priority);
+
+	// Get pointer to global policy options.  Caller is expected
+	// to do context checks like no setting once running.
+	HttpPolicyGlobal &	getGlobalOptions()
+		{
+			return mGlobalOptions;
+		}
+	
 	
 protected:
 	int					mReadyInClass[HttpRequest::POLICY_CLASS_LIMIT];
 	HttpReadyQueue		mReadyQueue[HttpRequest::POLICY_CLASS_LIMIT];
 	HttpService *		mService;				// Naked pointer, not refcounted, not owner
+	HttpPolicyGlobal	mGlobalOptions;
 	
 };  // end class HttpPolicy
 
diff --git a/indra/llcorehttp/_httpservice.h b/indra/llcorehttp/_httpservice.h
index 095316c8a7..748354a8e4 100644
--- a/indra/llcorehttp/_httpservice.h
+++ b/indra/llcorehttp/_httpservice.h
@@ -148,14 +148,14 @@ public:
 	/// Threading:  callable by worker thread.
 	bool changePriority(HttpHandle handle, HttpRequest::priority_t priority);
 	
-	HttpPolicy * getPolicy()
+	HttpPolicy & getPolicy()
 		{
-			return mPolicy;
+			return *mPolicy;
 		}
 
-	HttpLibcurl * getTransport()
+	HttpLibcurl & getTransport()
 		{
-			return mTransport;
+			return *mTransport;
 		}
 	
 protected:
diff --git a/indra/llcorehttp/httpcommon.cpp b/indra/llcorehttp/httpcommon.cpp
index a01182cf23..9f17b5c842 100644
--- a/indra/llcorehttp/httpcommon.cpp
+++ b/indra/llcorehttp/httpcommon.cpp
@@ -66,7 +66,10 @@ std::string HttpStatus::toString() const
 			"Services shutting down",
 			"Operation canceled",
 			"Invalid Content-Range header encountered",
-			"Request handle not found"
+			"Request handle not found",
+			"Invalid datatype for argument or option",
+			"Option has not been explicitly set",
+			"Option is not dynamic and must be set early"
 		};
 	static const int llcore_errors_count(sizeof(llcore_errors) / sizeof(llcore_errors[0]));
 
diff --git a/indra/llcorehttp/httpcommon.h b/indra/llcorehttp/httpcommon.h
index c01a5f85d3..fd2661b700 100644
--- a/indra/llcorehttp/httpcommon.h
+++ b/indra/llcorehttp/httpcommon.h
@@ -137,7 +137,16 @@ enum HttpError
 	HE_INV_CONTENT_RANGE_HDR = 4,
 	
 	// Request handle not found
-	HE_HANDLE_NOT_FOUND = 5
+	HE_HANDLE_NOT_FOUND = 5,
+
+	// Invalid datatype for option/setting
+	HE_INVALID_ARG = 6,
+
+	// Option hasn't been explicitly set
+	HE_OPT_NOT_SET = 7,
+	
+	// Option not dynamic, must be set during init phase
+	HE_OPT_NOT_DYNAMIC = 8
 	
 }; // end enum HttpError
 
diff --git a/indra/llcorehttp/httprequest.cpp b/indra/llcorehttp/httprequest.cpp
index 0e512d97ed..baa0fe1a84 100644
--- a/indra/llcorehttp/httprequest.cpp
+++ b/indra/llcorehttp/httprequest.cpp
@@ -29,6 +29,7 @@
 #include "_httprequestqueue.h"
 #include "_httpreplyqueue.h"
 #include "_httpservice.h"
+#include "_httppolicy.h"
 #include "_httpoperation.h"
 #include "_httpoprequest.h"
 #include "_httpopsetpriority.h"
@@ -127,9 +128,17 @@ HttpRequest::~HttpRequest()
 
 HttpStatus HttpRequest::setPolicyGlobalOption(EGlobalPolicy opt, long value)
 {
-	HttpStatus status;
+	// *FIXME:  Fail if thread is running.
 
-	return status;
+	return HttpService::instanceOf()->getPolicy().getGlobalOptions().set(opt, value);
+}
+
+
+HttpStatus HttpRequest::setPolicyGlobalOption(EGlobalPolicy opt, const std::string & value)
+{
+	// *FIXME:  Fail if thread is running.
+
+	return HttpService::instanceOf()->getPolicy().getGlobalOptions().set(opt, value);
 }
 
 
diff --git a/indra/llcorehttp/httprequest.h b/indra/llcorehttp/httprequest.h
index 57d2da245b..3592d5c6a3 100644
--- a/indra/llcorehttp/httprequest.h
+++ b/indra/llcorehttp/httprequest.h
@@ -111,7 +111,10 @@ public:
 		/// Maximum number of connections the library will use to
 		/// perform operations.  This is somewhat soft as the underlying
 		/// transport will cache some connections (up to 5).
-		GLOBAL_CONNECTION_LIMIT
+		GP_CONNECTION_LIMIT,		///< Takes long giving number of connections
+		GP_CA_PATH,					///< System path/directory where SSL certs are stored.
+		GP_CA_FILE,					///< System path/file containing certs.
+		GP_HTTP_PROXY				///< String giving host/port to use for HTTP proxy
 	};
 
 	/// Set a parameter on a global policy option.  Calls
@@ -122,6 +125,7 @@ public:
 	/// @param value	Desired value of option.
 	/// @return			Standard status code.
 	HttpStatus setPolicyGlobalOption(EGlobalPolicy opt, long value);
+	HttpStatus setPolicyGlobalOption(EGlobalPolicy opt, const std::string & value);
 
 	/// Create a new policy class into which requests can be made.
 	///
@@ -134,15 +138,15 @@ public:
 	enum EClassPolicy
 	{
 		/// Limits the number of connections used for the class.
-		CLASS_CONNECTION_LIMIT,
+		CP_CONNECTION_LIMIT,
 
 		/// Limits the number of connections used for a single
 		/// literal address/port pair within the class.
-		PER_HOST_CONNECTION_LIMIT,
+		CP_PER_HOST_CONNECTION_LIMIT,
 
 		/// Suitable requests are allowed to pipeline on their
 		/// connections when they ask for it.
-		ENABLE_PIPELINING
+		CP_ENABLE_PIPELINING
 	};
 	
 	/// Set a parameter on a class-based policy option.  Calls
@@ -153,9 +157,7 @@ public:
 	/// @param opt				Enum of option to be set.
 	/// @param value			Desired value of option.
 	/// @return					Standard status code.
-	HttpStatus setPolicyClassOption(policy_t policy_id,
-									EClassPolicy opt,
-									long value);
+	HttpStatus setPolicyClassOption(policy_t policy_id, EClassPolicy opt, long value);
 
 	/// @}
 
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 8e6deb9cce..7a44415fba 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -5356,6 +5356,17 @@ void CoreHttp::init()
 						<< LL_ENDL;
 	}
 
+	mRequest = new LLCore::HttpRequest;
+
+	status = mRequest->setPolicyGlobalOption(LLCore::HttpRequest::GP_CA_FILE,
+											 gDirUtilp->getCAFile());
+	if (! status)
+	{
+		LL_ERRS("Init") << "Failed to set CA File for HTTP services.  Reason:  "
+						<< status.toString()
+						<< LL_ENDL;
+	}
+	
 	status = LLCore::HttpRequest::startThread();
 	if (! status)
 	{
@@ -5364,7 +5375,6 @@ void CoreHttp::init()
 						<< LL_ENDL;
 	}
 
-	mRequest = new LLCore::HttpRequest;
 }
 
 
diff --git a/indra/newview/lltexturefetch.cpp b/indra/newview/lltexturefetch.cpp
index 34fb21798f..f9294b4cd1 100644
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
@@ -816,14 +816,6 @@ bool LLTextureFetchWorker::doWork(S32 param)
 		mFetchTimer.reset();
 	}
 
-	static LLUUID last_id;
-	if (mID != last_id)
-	{
-		// LL_WARNS("Texture") << "DOWORK SWITCH: " << last_id << " to: " << mID
-		// << LL_ENDL;
-		last_id = mID;
-	}
-	
 	if (mState == INIT)
 	{		
 		mRawImage = NULL ;
@@ -1109,10 +1101,6 @@ bool LLTextureFetchWorker::doWork(S32 param)
 									 << " Bytes: " << mRequestedSize
 									 << " Bandwidth(kbps): " << mFetcher->getTextureBandwidth() << "/" << mFetcher->mMaxBandwidth
 									 << LL_ENDL;
-// 				LL_WARNS("Texture") << "HTTP GET: " << mID << " Offset: " << mRequestedOffset
-// 									<< " Bytes: " << mRequestedSize
-// 									<< " Bandwidth(kbps): " << mFetcher->getTextureBandwidth() << "/" << mFetcher->mMaxBandwidth
-// 									<< LL_ENDL;
 
 				// Will call callbackHttpGet when curl request completes
 				// *FIXME:  enable redirection follow
@@ -1241,7 +1229,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 				}
 			}
 						
-			if (mHaveAllData && mRequestedDiscard == 0) //the image file is fully loaded.
+			if (mHaveAllData /* && mRequestedDiscard == 0*/) //the image file is fully loaded.
 			{
 				mFileSize = total_size;
 			}
@@ -1692,13 +1680,32 @@ S32 LLTextureFetchWorker::callbackHttpGet(LLCore::HttpResponse * response,
 			body->addRef();
 			mHttpBufferArray = body;
 
-			if (data_size < mRequestedSize && mRequestedDiscard == 0)
+			if (! partial)
+			{
+				// Response indicates this is the entire asset regardless
+				// of our asking for a byte range.  Mark it so and drop
+				// any partial data we might have so that the current
+				// response body becomes the entire dataset.
+				if (data_size <= mRequestedOffset)
+				{
+					LL_WARNS("Texture") << "Fetched entire texture " << mID
+										<< " when it was expected to be marked complete.  mImageSize:  "
+										<< mFileSize << " datasize:  " << mFormattedImage->getDataSize()
+										<< LL_ENDL;
+				}
+				mHaveAllData = TRUE;
+				llassert_always(mDecodeHandle == 0);
+				mFormattedImage = NULL; // discard any previous data we had
+			}
+			else if (data_size < mRequestedSize && mRequestedDiscard == 0)
 			{
+				// *FIXME:  I think we can treat this as complete regardless
+				// of requested discard level.  Revisit this...
 				mHaveAllData = TRUE;
 			}
 			else if (data_size > mRequestedSize)
 			{
-				// *TODO: This shouldn't be happening any more
+				// *TODO: This shouldn't be happening any more  (REALLY don't expect this anymore)
 				llwarns << "data_size = " << data_size << " > requested: " << mRequestedSize << llendl;
 				mHaveAllData = TRUE;
 				llassert_always(mDecodeHandle == 0);
-- 
cgit v1.3


From 7adeb3923728ca84a309a6af141c148ce38066fc Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Tue, 12 Jun 2012 17:42:33 -0400
Subject: HTTP Proxy, PUT & POST, unit tests and refactoring.
 Implemented/modified PUT & POST to not used chunked encoding for the request.
 Made the unit test much happier and probably a better thing for the pipeline.
 Have a cheesy static & dynamic proxy capability using both local options and
 a way to wire into LLProxy in llmessages.  Not a clean thing but it will get
 the proxy path working with both socks5 & http proxies.  Refactoring to get
 rid of unneeded library handler and unified an HttpStatus return for all
 requests.  Big batch of code removed as a result of that and more is possible
 as well as some syscall avoidance with a bit more work.  Boosted the unit
 tests for simple PUT & POST test which revealed the test harness does *not*
 like chunked encoding so we'll avoid it for now (and don't really need it in
 any of our schemes).

---
 indra/llcorehttp/CMakeLists.txt                |   5 +
 indra/llcorehttp/_httpopcancel.cpp             |  11 --
 indra/llcorehttp/_httpopcancel.h               |   3 -
 indra/llcorehttp/_httpoperation.cpp            |  18 +-
 indra/llcorehttp/_httpoperation.h              |  13 +-
 indra/llcorehttp/_httpoprequest.cpp            |  63 +++++--
 indra/llcorehttp/_httpoprequest.h              |   7 +
 indra/llcorehttp/_httpopsetget.cpp             | 105 +++++++++++
 indra/llcorehttp/_httpopsetget.h               |  78 ++++++++
 indra/llcorehttp/_httpopsetpriority.cpp        |  14 --
 indra/llcorehttp/_httpopsetpriority.h          |   4 +-
 indra/llcorehttp/_httppolicy.cpp               |   6 +
 indra/llcorehttp/_httppolicy.h                 |   4 +-
 indra/llcorehttp/_httppolicyglobal.cpp         |  38 ++--
 indra/llcorehttp/_httppolicyglobal.h           |   7 +-
 indra/llcorehttp/_httpservice.cpp              |  11 +-
 indra/llcorehttp/_httpservice.h                |  10 +-
 indra/llcorehttp/httprequest.cpp               | 151 ++++++++--------
 indra/llcorehttp/httprequest.h                 |  44 ++++-
 indra/llcorehttp/tests/llcorehttp_test.cpp     |   6 +
 indra/llcorehttp/tests/test_httpoperation.hpp  |   5 +-
 indra/llcorehttp/tests/test_httprequest.hpp    | 239 +++++++++++++++++++++++++
 indra/llcorehttp/tests/test_llcorehttp_peer.py |  10 +-
 indra/newview/llappviewer.cpp                  |  13 ++
 24 files changed, 702 insertions(+), 163 deletions(-)
 create mode 100644 indra/llcorehttp/_httpopsetget.cpp
 create mode 100644 indra/llcorehttp/_httpopsetget.h

(limited to 'indra/newview/llappviewer.cpp')

diff --git a/indra/llcorehttp/CMakeLists.txt b/indra/llcorehttp/CMakeLists.txt
index a0827286e3..4273b32fe3 100644
--- a/indra/llcorehttp/CMakeLists.txt
+++ b/indra/llcorehttp/CMakeLists.txt
@@ -10,12 +10,14 @@ include(OpenSSL)
 include(ZLIB)
 include(LLCoreHttp)
 include(LLAddBuildTest)
+include(LLMessage)
 include(LLCommon)
 include(Tut)
 
 include_directories (${CMAKE_CURRENT_SOURCE_DIR})
 
 include_directories(
+    ${LLMESSAGE_INCLUDE_DIRS}
     ${LLCOMMON_INCLUDE_DIRS}
     ${LLCOREHTTP_INCLUDE_DIRS}
     )
@@ -31,6 +33,7 @@ set(llcorehttp_SOURCE_FILES
     _httpopcancel.cpp
     _httpoperation.cpp
     _httpoprequest.cpp
+    _httpopsetget.cpp
     _httpopsetpriority.cpp
     _httppolicy.cpp
     _httppolicyglobal.cpp
@@ -54,6 +57,7 @@ set(llcorehttp_HEADER_FILES
     _httpopcancel.h
     _httpoperation.h
     _httpoprequest.h
+    _httpopsetget.h
     _httpopsetpriority.h
     _httppolicy.h
     _httppolicyglobal.h
@@ -113,6 +117,7 @@ if (LL_TESTS)
   set(test_libs
       ${LLCOREHTTP_LIBRARIES}
       ${WINDOWS_LIBRARIES}
+      ${LLMESSAGE_LIBRARIES}
       ${LLCOMMON_LIBRARIES}
       ${GOOGLEMOCK_LIBRARIES}
       ${CURL_LIBRARIES}
diff --git a/indra/llcorehttp/_httpopcancel.cpp b/indra/llcorehttp/_httpopcancel.cpp
index 69dbff4bb4..ad624d2e57 100644
--- a/indra/llcorehttp/_httpopcancel.cpp
+++ b/indra/llcorehttp/_httpopcancel.cpp
@@ -66,17 +66,6 @@ void HttpOpCancel::stageFromRequest(HttpService * service)
 }
 
 
-void HttpOpCancel::visitNotifier(HttpRequest * request)
-{
-	if (mLibraryHandler)
-	{
-		HttpResponse * response = new HttpResponse();
-		mLibraryHandler->onCompleted(static_cast<HttpHandle>(this), response);
-		response->release();
-	}
-}
-
-
 }   // end namespace LLCore
 
 		
diff --git a/indra/llcorehttp/_httpopcancel.h b/indra/llcorehttp/_httpopcancel.h
index fab6f1f362..6d1e0f8774 100644
--- a/indra/llcorehttp/_httpopcancel.h
+++ b/indra/llcorehttp/_httpopcancel.h
@@ -59,13 +59,10 @@ private:
 
 public:
 	virtual void stageFromRequest(HttpService *);
-
-	virtual void visitNotifier(HttpRequest * request);
 			
 public:
 	// Request data
 	HttpHandle			mHandle;
-
 };  // end class HttpOpCancel
 
 
diff --git a/indra/llcorehttp/_httpoperation.cpp b/indra/llcorehttp/_httpoperation.cpp
index d966efd12b..b5c58013d4 100644
--- a/indra/llcorehttp/_httpoperation.cpp
+++ b/indra/llcorehttp/_httpoperation.cpp
@@ -47,7 +47,6 @@ namespace LLCore
 HttpOperation::HttpOperation()
 	: LLCoreInt::RefCounted(true),
 	  mReplyQueue(NULL),
-	  mLibraryHandler(NULL),
 	  mUserHandler(NULL),
 	  mReqPolicy(HttpRequest::DEFAULT_POLICY_ID),
 	  mReqPriority(0U)
@@ -57,13 +56,12 @@ HttpOperation::HttpOperation()
 
 HttpOperation::~HttpOperation()
 {
-	setHandlers(NULL, NULL, NULL);
+	setReplyPath(NULL, NULL);
 }
 
 
-void HttpOperation::setHandlers(HttpReplyQueue * reply_queue,
-								HttpHandler * lib_handler,
-								HttpHandler * user_handler)
+void HttpOperation::setReplyPath(HttpReplyQueue * reply_queue,
+								 HttpHandler * user_handler)
 {
 	if (reply_queue != mReplyQueue)
 	{
@@ -80,9 +78,6 @@ void HttpOperation::setHandlers(HttpReplyQueue * reply_queue,
 		mReplyQueue = reply_queue;
 	}
 
-	// Not refcounted
-	mLibraryHandler = lib_handler;
-
 	// Not refcounted
 	mUserHandler = user_handler;
 }
@@ -121,11 +116,12 @@ void HttpOperation::stageFromActive(HttpService *)
 	
 void HttpOperation::visitNotifier(HttpRequest *)
 {
-	if (mLibraryHandler)
+	if (mUserHandler)
 	{
 		HttpResponse * response = new HttpResponse();
 
-		mLibraryHandler->onCompleted(static_cast<HttpHandle>(this), response);
+		response->setStatus(mStatus);
+		mUserHandler->onCompleted(static_cast<HttpHandle>(this), response);
 
 		response->release();
 	}
@@ -142,7 +138,7 @@ HttpStatus HttpOperation::cancel()
 
 void HttpOperation::addAsReply()
 {
-	if (mReplyQueue && mLibraryHandler)
+	if (mReplyQueue)
 	{
 		addRef();
 		mReplyQueue->addOp(this);
diff --git a/indra/llcorehttp/_httpoperation.h b/indra/llcorehttp/_httpoperation.h
index 01e26029d2..c93aa2def9 100644
--- a/indra/llcorehttp/_httpoperation.h
+++ b/indra/llcorehttp/_httpoperation.h
@@ -80,9 +80,8 @@ private:
 	void operator=(const HttpOperation &);				// Not defined
 
 public:
-	void setHandlers(HttpReplyQueue * reply_queue,
-					 HttpHandler * lib_handler,
-					 HttpHandler * user_handler);
+	void setReplyPath(HttpReplyQueue * reply_queue,
+					  HttpHandler * handler);
 
 	HttpHandler * getUserHandler() const
 		{
@@ -102,13 +101,15 @@ protected:
 	
 protected:
 	HttpReplyQueue *			mReplyQueue;			// Have refcount
-	HttpHandler *				mLibraryHandler;		// Have refcount
-	HttpHandler *				mUserHandler;			// Have refcount
+	HttpHandler *				mUserHandler;
 
 public:
+	// Request Data
 	HttpRequest::policy_t		mReqPolicy;
 	HttpRequest::priority_t		mReqPriority;
-	
+
+	// Reply Data
+	HttpStatus					mStatus;
 };  // end class HttpOperation
 
 
diff --git a/indra/llcorehttp/_httpoprequest.cpp b/indra/llcorehttp/_httpoprequest.cpp
index ea0b99303e..e2550d057e 100644
--- a/indra/llcorehttp/_httpoprequest.cpp
+++ b/indra/llcorehttp/_httpoprequest.cpp
@@ -44,6 +44,7 @@
 #include "_httplibcurl.h"
 
 #include "llhttpstatuscodes.h"
+#include "llproxy.h"
 
 namespace
 {
@@ -207,7 +208,7 @@ void HttpOpRequest::visitNotifier(HttpRequest * request)
 {
 	static const HttpStatus partial_content(HTTP_PARTIAL_CONTENT, HE_SUCCESS);
 	
-	if (mLibraryHandler)
+	if (mUserHandler)
 	{
 		HttpResponse * response = new HttpResponse();
 		response->setStatus(mStatus);
@@ -219,7 +220,7 @@ void HttpOpRequest::visitNotifier(HttpRequest * request)
 			response->setRange(mReplyOffset, mReplyLength);
 		}
 
-		mLibraryHandler->onCompleted(static_cast<HttpHandle>(this), response);
+		mUserHandler->onCompleted(static_cast<HttpHandle>(this), response);
 
 		response->release();
 	}
@@ -304,6 +305,39 @@ HttpStatus HttpOpRequest::setupPost(HttpRequest::policy_t policy_id,
 }
 
 
+HttpStatus HttpOpRequest::setupPut(HttpRequest::policy_t policy_id,
+								   HttpRequest::priority_t priority,
+								   const std::string & url,
+								   BufferArray * body,
+								   HttpOptions * options,
+								   HttpHeaders * headers)
+{
+	HttpStatus status;
+
+	mProcFlags = 0;
+	mReqPolicy = policy_id;
+	mReqPriority = priority;
+	mReqMethod = HOR_PUT;
+	mReqURL = url;
+	if (body)
+	{
+		body->addRef();
+		mReqBody = body;
+	}
+	if (headers && ! mReqHeaders)
+	{
+		headers->addRef();
+		mReqHeaders = headers;
+	}
+	if (options && ! mReqOptions)
+	{
+		mReqOptions = new HttpOptions(*options);
+	}
+	
+	return status;
+}
+
+
 HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 {
 	// Scrub transport and result data for retried op case
@@ -346,8 +380,6 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 	curl_easy_setopt(mCurlHandle, CURLOPT_URL, mReqURL.c_str());
 	curl_easy_setopt(mCurlHandle, CURLOPT_PRIVATE, this);
 	curl_easy_setopt(mCurlHandle, CURLOPT_ENCODING, "");
-	// *FIXME:  Need to deal with proxy setup...
-	// curl_easy_setopt(handle, CURLOPT_PROXY, "");
 
 	// *FIXME:  Revisit this old DNS timeout setting - may no longer be valid
 	curl_easy_setopt(mCurlHandle, CURLOPT_DNS_CACHE_TIMEOUT, 0);
@@ -361,18 +393,31 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 	curl_easy_setopt(mCurlHandle, CURLOPT_SSL_VERIFYPEER, 1);
 	curl_easy_setopt(mCurlHandle, CURLOPT_SSL_VERIFYHOST, 0);
 
-	std::string opt_value;
+	const std::string * opt_value(NULL);
 	if (policy.get(HttpRequest::GP_CA_PATH, opt_value))
 	{
-		curl_easy_setopt(mCurlHandle, CURLOPT_CAPATH, opt_value.c_str());
+		curl_easy_setopt(mCurlHandle, CURLOPT_CAPATH, opt_value->c_str());
 	}
 	if (policy.get(HttpRequest::GP_CA_FILE, opt_value))
 	{
-		curl_easy_setopt(mCurlHandle, CURLOPT_CAINFO, opt_value.c_str());
+		curl_easy_setopt(mCurlHandle, CURLOPT_CAINFO, opt_value->c_str());
 	}
 	if (policy.get(HttpRequest::GP_HTTP_PROXY, opt_value))
 	{
-		curl_easy_setopt(mCurlHandle, CURLOPT_PROXY, opt_value.c_str());
+		if (*opt_value == "LLProxy")
+		{
+			// Use the viewer-based thread-safe API which has a
+			// fast/safe check for proxy enable.  Would like to
+			// encapsulate this someway...
+			LLProxy::getInstance()->applyProxySettings(mCurlHandle);
+		}
+		else
+		{
+			// *TODO:  This is fine for now but get fuller socks/
+			// authentication thing going later....
+			curl_easy_setopt(mCurlHandle, CURLOPT_PROXY, opt_value->c_str());
+			curl_easy_setopt(mCurlHandle, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
+		}
 	}
 	
 	switch (mReqMethod)
@@ -394,7 +439,6 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 			}
 			curl_easy_setopt(mCurlHandle, CURLOPT_POSTFIELDS, static_cast<void *>(NULL));
 			curl_easy_setopt(mCurlHandle, CURLOPT_POSTFIELDSIZE, data_size);
-			mCurlHeaders = curl_slist_append(mCurlHeaders, "Transfer-Encoding: chunked");
 			mCurlHeaders = curl_slist_append(mCurlHeaders, "Expect:");
 		}
 		break;
@@ -409,7 +453,6 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 			}
 			curl_easy_setopt(mCurlHandle, CURLOPT_INFILESIZE, data_size);
 			curl_easy_setopt(mCurlHandle, CURLOPT_POSTFIELDS, (void *) NULL);
-			mCurlHeaders = curl_slist_append(mCurlHeaders, "Transfer-Encoding: chunked");
 			mCurlHeaders = curl_slist_append(mCurlHeaders, "Expect:");
 			mCurlHeaders = curl_slist_append(mCurlHeaders, "Connection: keep-alive");
 			mCurlHeaders = curl_slist_append(mCurlHeaders, "Keep-alive: 300");
diff --git a/indra/llcorehttp/_httpoprequest.h b/indra/llcorehttp/_httpoprequest.h
index 6dcf30ca0c..80893beb40 100644
--- a/indra/llcorehttp/_httpoprequest.h
+++ b/indra/llcorehttp/_httpoprequest.h
@@ -91,6 +91,13 @@ public:
 						 HttpOptions * options,
 						 HttpHeaders * headers);
 	
+	HttpStatus setupPut(HttpRequest::policy_t policy_id,
+						HttpRequest::priority_t priority,
+						const std::string & url,
+						BufferArray * body,
+						HttpOptions * options,
+						HttpHeaders * headers);
+	
 	HttpStatus prepareRequest(HttpService * service);
 	
 	virtual HttpStatus cancel();
diff --git a/indra/llcorehttp/_httpopsetget.cpp b/indra/llcorehttp/_httpopsetget.cpp
new file mode 100644
index 0000000000..21e058b2be
--- /dev/null
+++ b/indra/llcorehttp/_httpopsetget.cpp
@@ -0,0 +1,105 @@
+/**
+ * @file _httpopsetget.cpp
+ * @brief Definitions for internal class HttpOpSetGet
+ *
+ * $LicenseInfo:firstyear=2012&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2012, 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$
+ */
+
+#include "_httpopsetget.h"
+
+#include <cstdio>
+#include <algorithm>
+
+#include "httpcommon.h"
+#include "httphandler.h"
+#include "httpresponse.h"
+
+#include "_httprequestqueue.h"
+#include "_httpreplyqueue.h"
+#include "_httpservice.h"
+#include "_httppolicy.h"
+#include "_httplibcurl.h"
+
+
+namespace LLCore
+{
+
+
+// ==================================
+// HttpOpSetget
+// ==================================
+
+
+HttpOpSetGet::HttpOpSetGet()
+	: HttpOperation(),
+	  mIsGlobal(false),
+	  mDoSet(false),
+	  mSetting(-1),				// Nothing requested
+	  mLongValue(0L)
+{}
+
+
+HttpOpSetGet::~HttpOpSetGet()
+{}
+
+
+void HttpOpSetGet::setupGet(HttpRequest::EGlobalPolicy setting)
+{
+	mIsGlobal = true;
+	mSetting = setting;
+}
+
+
+void HttpOpSetGet::setupSet(HttpRequest::EGlobalPolicy setting, const std::string & value)
+{
+	mIsGlobal = true;
+	mDoSet = true;
+	mSetting = setting;
+	mStrValue = value;
+}
+
+
+void HttpOpSetGet::stageFromRequest(HttpService * service)
+{
+	HttpPolicyGlobal & pol_opt(service->getPolicy().getGlobalOptions());
+	HttpRequest::EGlobalPolicy setting(static_cast<HttpRequest::EGlobalPolicy>(mSetting));
+	
+	if (mDoSet)
+	{
+		mStatus = pol_opt.set(setting, mStrValue);
+	}
+	if (mStatus)
+	{
+		const std::string * value;
+		if ((mStatus = pol_opt.get(setting, value)))
+		{
+			mStrValue = *value;
+		}
+	}
+	
+	addAsReply();
+}
+
+
+}   // end namespace LLCore
+
+		
diff --git a/indra/llcorehttp/_httpopsetget.h b/indra/llcorehttp/_httpopsetget.h
new file mode 100644
index 0000000000..e065eb4c30
--- /dev/null
+++ b/indra/llcorehttp/_httpopsetget.h
@@ -0,0 +1,78 @@
+/**
+ * @file _httpopsetget.h
+ * @brief Internal declarations for the HttpOpSetGet subclass
+ *
+ * $LicenseInfo:firstyear=2012&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2012, 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$
+ */
+
+#ifndef	_LLCORE_HTTP_OPSETGET_H_
+#define	_LLCORE_HTTP_OPSETGET_H_
+
+
+#include "linden_common.h"		// Modifies curl/curl.h interfaces
+
+#include "httpcommon.h"
+
+#include <curl/curl.h>
+
+#include "_httpoperation.h"
+#include "_refcounted.h"
+
+
+namespace LLCore
+{
+
+
+/// HttpOpSetGet requests dynamic changes to policy and
+/// configuration settings.
+
+class HttpOpSetGet : public HttpOperation
+{
+public:
+	HttpOpSetGet();
+	virtual ~HttpOpSetGet();
+
+private:
+	HttpOpSetGet(const HttpOpSetGet &);					// Not defined
+	void operator=(const HttpOpSetGet &);				// Not defined
+
+public:
+	void setupGet(HttpRequest::EGlobalPolicy setting);
+	void setupSet(HttpRequest::EGlobalPolicy setting, const std::string & value);
+
+	virtual void stageFromRequest(HttpService *);
+
+public:
+	// Request data
+	bool				mIsGlobal;
+	bool				mDoSet;
+	int					mSetting;
+	long				mLongValue;
+	std::string			mStrValue;
+
+};  // end class HttpOpSetGet
+
+
+}   // end namespace LLCore
+
+#endif	// _LLCORE_HTTP_OPSETGET_H_
+
diff --git a/indra/llcorehttp/_httpopsetpriority.cpp b/indra/llcorehttp/_httpopsetpriority.cpp
index b0ee577087..d48c7a0b7d 100644
--- a/indra/llcorehttp/_httpopsetpriority.cpp
+++ b/indra/llcorehttp/_httpopsetpriority.cpp
@@ -60,18 +60,4 @@ void HttpOpSetPriority::stageFromRequest(HttpService * service)
 }
 
 
-void HttpOpSetPriority::visitNotifier(HttpRequest * request)
-{
-	if (mLibraryHandler)
-	{
-		HttpResponse * response = new HttpResponse();
-
-		response->setStatus(mStatus);
-		mLibraryHandler->onCompleted(static_cast<HttpHandle>(this), response);
-
-		response->release();
-	}
-}
-
-
 }   // end namespace LLCore
diff --git a/indra/llcorehttp/_httpopsetpriority.h b/indra/llcorehttp/_httpopsetpriority.h
index b972f50fff..f1e94b6e43 100644
--- a/indra/llcorehttp/_httpopsetpriority.h
+++ b/indra/llcorehttp/_httpopsetpriority.h
@@ -56,10 +56,8 @@ private:
 public:
 	virtual void stageFromRequest(HttpService *);
 
-	virtual void visitNotifier(HttpRequest * request);
-
 protected:
-	HttpStatus					mStatus;
+	// Request Data
 	HttpHandle					mHandle;
 	HttpRequest::priority_t		mPriority;
 }; // end class HttpOpSetPriority
diff --git a/indra/llcorehttp/_httppolicy.cpp b/indra/llcorehttp/_httppolicy.cpp
index 72bb6f14e4..8ee3f88658 100644
--- a/indra/llcorehttp/_httppolicy.cpp
+++ b/indra/llcorehttp/_httppolicy.cpp
@@ -71,6 +71,12 @@ HttpPolicy::~HttpPolicy()
 }
 
 
+void HttpPolicy::setPolicies(const HttpPolicyGlobal & global)
+{
+	mGlobalOptions = global;
+}
+
+
 void HttpPolicy::addOp(HttpOpRequest * op)
 {
 	const int policy_class(op->mReqPolicy);
diff --git a/indra/llcorehttp/_httppolicy.h b/indra/llcorehttp/_httppolicy.h
index 14f6a9a676..73c22bab78 100644
--- a/indra/llcorehttp/_httppolicy.h
+++ b/indra/llcorehttp/_httppolicy.h
@@ -95,7 +95,9 @@ public:
 		{
 			return mGlobalOptions;
 		}
-	
+
+	void setPolicies(const HttpPolicyGlobal & global);
+			
 protected:
 	struct State
 	{
diff --git a/indra/llcorehttp/_httppolicyglobal.cpp b/indra/llcorehttp/_httppolicyglobal.cpp
index 877b85896f..d95d73cfba 100644
--- a/indra/llcorehttp/_httppolicyglobal.cpp
+++ b/indra/llcorehttp/_httppolicyglobal.cpp
@@ -32,7 +32,7 @@ namespace LLCore
 
 
 HttpPolicyGlobal::HttpPolicyGlobal()
-	: mValidMask(0UL),
+	: mSetMask(0UL),
 	  mConnectionLimit(32L)
 {}
 
@@ -41,6 +41,20 @@ HttpPolicyGlobal::~HttpPolicyGlobal()
 {}
 
 
+HttpPolicyGlobal & HttpPolicyGlobal::operator=(const HttpPolicyGlobal & other)
+{
+	if (this != &other)
+	{
+		mSetMask = other.mSetMask;
+		mConnectionLimit = other.mConnectionLimit;
+		mCAPath = other.mCAPath;
+		mCAFile = other.mCAFile;
+		mHttpProxy = other.mHttpProxy;
+	}
+	return *this;
+}
+
+
 HttpStatus HttpPolicyGlobal::set(HttpRequest::EGlobalPolicy opt, long value)
 {
 	switch (opt)
@@ -53,7 +67,7 @@ HttpStatus HttpPolicyGlobal::set(HttpRequest::EGlobalPolicy opt, long value)
 		return HttpStatus(HttpStatus::LLCORE, HE_INVALID_ARG);
 	}
 
-	mValidMask |= 1UL << int(opt);
+	mSetMask |= 1UL << int(opt);
 	return HttpStatus();
 }
 
@@ -78,7 +92,7 @@ HttpStatus HttpPolicyGlobal::set(HttpRequest::EGlobalPolicy opt, const std::stri
 		return HttpStatus(HttpStatus::LLCORE, HE_INVALID_ARG);
 	}
 	
-	mValidMask |= 1UL << int(opt);
+	mSetMask |= 1UL << int(opt);
 	return HttpStatus();
 }
 
@@ -90,7 +104,7 @@ HttpStatus HttpPolicyGlobal::get(HttpRequest::EGlobalPolicy opt, long & value)
 	switch (opt)
 	{
 	case HttpRequest::GP_CONNECTION_LIMIT:
-		if (! (mValidMask & (1UL << int(opt))))
+		if (! (mSetMask & (1UL << int(opt))))
 			return not_set;
 		value = mConnectionLimit;
 		break;
@@ -103,28 +117,28 @@ HttpStatus HttpPolicyGlobal::get(HttpRequest::EGlobalPolicy opt, long & value)
 }
 
 
-HttpStatus HttpPolicyGlobal::get(HttpRequest::EGlobalPolicy opt, std::string & value)
+HttpStatus HttpPolicyGlobal::get(HttpRequest::EGlobalPolicy opt, const std::string *& value)
 {
 	static const HttpStatus not_set(HttpStatus::LLCORE, HE_OPT_NOT_SET);
-	
+
 	switch (opt)
 	{
 	case HttpRequest::GP_CA_PATH:
-		if (! (mValidMask & (1UL << int(opt))))
+		if (! (mSetMask & (1UL << int(opt))))
 			return not_set;
-		value = mCAPath;
+		value = &mCAPath;
 		break;
 
 	case HttpRequest::GP_CA_FILE:
-		if (! (mValidMask & (1UL << int(opt))))
+		if (! (mSetMask & (1UL << int(opt))))
 			return not_set;
-		value = mCAFile;
+		value = &mCAFile;
 		break;
 
 	case HttpRequest::GP_HTTP_PROXY:
-		if (! (mValidMask & (1UL << int(opt))))
+		if (! (mSetMask & (1UL << int(opt))))
 			return not_set;
-		value = mHttpProxy;
+		value = &mHttpProxy;
 		break;
 
 	default:
diff --git a/indra/llcorehttp/_httppolicyglobal.h b/indra/llcorehttp/_httppolicyglobal.h
index 39ffbcb9bb..f4bb4d4b25 100644
--- a/indra/llcorehttp/_httppolicyglobal.h
+++ b/indra/llcorehttp/_httppolicyglobal.h
@@ -40,18 +40,19 @@ public:
 	HttpPolicyGlobal();
 	~HttpPolicyGlobal();
 
+	HttpPolicyGlobal & operator=(const HttpPolicyGlobal &);
+	
 private:
 	HttpPolicyGlobal(const HttpPolicyGlobal &);			// Not defined
-	void operator=(const HttpPolicyGlobal &);			// Not defined
 
 public:
 	HttpStatus set(HttpRequest::EGlobalPolicy opt, long value);
 	HttpStatus set(HttpRequest::EGlobalPolicy opt, const std::string & value);
 	HttpStatus get(HttpRequest::EGlobalPolicy opt, long & value);
-	HttpStatus get(HttpRequest::EGlobalPolicy opt, std::string & value);
+	HttpStatus get(HttpRequest::EGlobalPolicy opt, const std::string *& value);
 	
 public:
-	unsigned long		mValidMask;
+	unsigned long		mSetMask;
 	long				mConnectionLimit;
 	std::string			mCAPath;
 	std::string			mCAFile;
diff --git a/indra/llcorehttp/_httpservice.cpp b/indra/llcorehttp/_httpservice.cpp
index b038bdb720..920a3f3b6d 100644
--- a/indra/llcorehttp/_httpservice.cpp
+++ b/indra/llcorehttp/_httpservice.cpp
@@ -79,11 +79,8 @@ HttpService::~HttpService()
 		mTransport = NULL;
 	}
 	
-	if (mPolicy)
-	{
-		delete mPolicy;
-		mPolicy = NULL;
-	}
+	delete mPolicy;
+	mPolicy = NULL;
 
 	if (mThread)
 	{
@@ -145,6 +142,10 @@ void HttpService::startThread()
 	{
 		mThread->release();
 	}
+
+	// Push current policy definitions
+	mPolicy->setPolicies(mPolicyGlobal);
+	
 	mThread = new LLCoreInt::HttpThread(boost::bind(&HttpService::threadRun, this, _1));
 	mThread->addRef();		// Need an explicit reference, implicit one is used internally
 	sState = RUNNING;
diff --git a/indra/llcorehttp/_httpservice.h b/indra/llcorehttp/_httpservice.h
index 748354a8e4..3f953ec1a7 100644
--- a/indra/llcorehttp/_httpservice.h
+++ b/indra/llcorehttp/_httpservice.h
@@ -30,6 +30,7 @@
 
 #include "httpcommon.h"
 #include "httprequest.h"
+#include "_httppolicyglobal.h"
 
 
 namespace LLCoreInt
@@ -157,6 +158,11 @@ public:
 		{
 			return *mTransport;
 		}
+
+	HttpPolicyGlobal & getGlobalOptions()
+		{
+			return mPolicyGlobal;
+		}
 	
 protected:
 	void threadRun(LLCoreInt::HttpThread * thread);
@@ -173,11 +179,11 @@ protected:
 	
 	// === calling-thread-only data ===
 	LLCoreInt::HttpThread *		mThread;
-
+	HttpPolicyGlobal			mPolicyGlobal;
+	
 	// === working-thread-only data ===
 	HttpPolicy *				mPolicy;		// Simple pointer, has ownership
 	HttpLibcurl *				mTransport;		// Simple pointer, has ownership
-	
 };  // end class HttpService
 
 }  // end namespace LLCore
diff --git a/indra/llcorehttp/httprequest.cpp b/indra/llcorehttp/httprequest.cpp
index 2f36168f8b..089eee76f3 100644
--- a/indra/llcorehttp/httprequest.cpp
+++ b/indra/llcorehttp/httprequest.cpp
@@ -34,6 +34,7 @@
 #include "_httpoprequest.h"
 #include "_httpopsetpriority.h"
 #include "_httpopcancel.h"
+#include "_httpopsetget.h"
 
 #include "lltimer.h"
 
@@ -48,39 +49,6 @@ bool has_inited(false);
 namespace LLCore
 {
 
-// ====================================
-// InternalHandler Implementation
-// ====================================
-
-
-class HttpRequest::InternalHandler : public HttpHandler
-{
-public:
-	InternalHandler(HttpRequest & request)
-		: mRequest(request)
-		{}
-
-protected:
-	InternalHandler(const InternalHandler &);			// Not defined
-	void operator=(const InternalHandler &);			// Not defined
-
-public:
-	void onCompleted(HttpHandle handle, HttpResponse * response)
-		{
-			HttpOperation * op(static_cast<HttpOperation *>(handle));
-			HttpHandler * user_handler(op->getUserHandler());
-			if (user_handler)
-			{
-				user_handler->onCompleted(handle, response);
-			}
-		}
-
-protected:
-	HttpRequest &		mRequest;
-	
-};  // end class HttpRequest::InternalHandler
-
-
 // ====================================
 // HttpRequest Implementation
 // ====================================
@@ -92,15 +60,12 @@ HttpRequest::policy_t HttpRequest::sNextPolicyID(1);
 HttpRequest::HttpRequest()
 	: //HttpHandler(),
 	  mReplyQueue(NULL),
-	  mRequestQueue(NULL),
-	  mSelfHandler(NULL)
+	  mRequestQueue(NULL)
 {
 	mRequestQueue = HttpRequestQueue::instanceOf();
 	mRequestQueue->addRef();
 
 	mReplyQueue = new HttpReplyQueue();
-
-	mSelfHandler = new InternalHandler(*this);
 }
 
 
@@ -117,9 +82,6 @@ HttpRequest::~HttpRequest()
 		mReplyQueue->release();
 		mReplyQueue = NULL;
 	}
-
-	delete mSelfHandler;
-	mSelfHandler = NULL;
 }
 
 
@@ -132,7 +94,7 @@ HttpStatus HttpRequest::setPolicyGlobalOption(EGlobalPolicy opt, long value)
 {
 	// *FIXME:  Fail if thread is running.
 
-	return HttpService::instanceOf()->getPolicy().getGlobalOptions().set(opt, value);
+	return HttpService::instanceOf()->getGlobalOptions().set(opt, value);
 }
 
 
@@ -140,7 +102,7 @@ HttpStatus HttpRequest::setPolicyGlobalOption(EGlobalPolicy opt, const std::stri
 {
 	// *FIXME:  Fail if thread is running.
 
-	return HttpService::instanceOf()->getPolicy().getGlobalOptions().set(opt, value);
+	return HttpService::instanceOf()->getGlobalOptions().set(opt, value);
 }
 
 
@@ -192,7 +154,7 @@ HttpHandle HttpRequest::requestGetByteRange(policy_t policy_id,
 		mLastReqStatus = status;
 		return handle;
 	}
-	op->setHandlers(mReplyQueue, mSelfHandler, user_handler);
+	op->setReplyPath(mReplyQueue, user_handler);
 	mRequestQueue->addOp(op);			// transfers refcount
 	
 	mLastReqStatus = status;
@@ -220,7 +182,7 @@ HttpHandle HttpRequest::requestPost(policy_t policy_id,
 		mLastReqStatus = status;
 		return handle;
 	}
-	op->setHandlers(mReplyQueue, mSelfHandler, user_handler);
+	op->setReplyPath(mReplyQueue, user_handler);
 	mRequestQueue->addOp(op);			// transfers refcount
 	
 	mLastReqStatus = status;
@@ -230,19 +192,31 @@ HttpHandle HttpRequest::requestPost(policy_t policy_id,
 }
 
 
-HttpHandle HttpRequest::requestCancel(HttpHandle handle, HttpHandler * user_handler)
+HttpHandle HttpRequest::requestPut(policy_t policy_id,
+								   priority_t priority,
+								   const std::string & url,
+								   BufferArray * body,
+								   HttpOptions * options,
+								   HttpHeaders * headers,
+								   HttpHandler * user_handler)
 {
 	HttpStatus status;
-	HttpHandle ret_handle(LLCORE_HTTP_HANDLE_INVALID);
-
-	HttpOpCancel * op = new HttpOpCancel(handle);
-	op->setHandlers(mReplyQueue, mSelfHandler, user_handler);
-	mRequestQueue->addOp(op);			// transfer refcount as well
+	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
+	HttpOpRequest * op = new HttpOpRequest();
+	if (! (status = op->setupPut(policy_id, priority, url, body, options, headers)))
+	{
+		op->release();
+		mLastReqStatus = status;
+		return handle;
+	}
+	op->setReplyPath(mReplyQueue, user_handler);
+	mRequestQueue->addOp(op);			// transfers refcount
+	
 	mLastReqStatus = status;
-	ret_handle = static_cast<HttpHandle>(op);
+	handle = static_cast<HttpHandle>(op);
 	
-	return ret_handle;
+	return handle;
 }
 
 
@@ -252,7 +226,7 @@ HttpHandle HttpRequest::requestNoOp(HttpHandler * user_handler)
 	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
 	HttpOpNull * op = new HttpOpNull();
-	op->setHandlers(mReplyQueue, mSelfHandler, user_handler);
+	op->setReplyPath(mReplyQueue, user_handler);
 	mRequestQueue->addOp(op);			// transfer refcount as well
 
 	mLastReqStatus = status;
@@ -262,23 +236,6 @@ HttpHandle HttpRequest::requestNoOp(HttpHandler * user_handler)
 }
 
 
-HttpHandle HttpRequest::requestSetPriority(HttpHandle request, priority_t priority,
-										   HttpHandler * handler)
-{
-	HttpStatus status;
-	HttpHandle ret_handle(LLCORE_HTTP_HANDLE_INVALID);
-
-	HttpOpSetPriority * op = new HttpOpSetPriority(request, priority);
-	op->setHandlers(mReplyQueue, mSelfHandler, handler);
-	mRequestQueue->addOp(op);			// transfer refcount as well
-
-	mLastReqStatus = status;
-	ret_handle = static_cast<HttpHandle>(op);
-	
-	return ret_handle;
-}
-
-
 HttpStatus HttpRequest::update(long millis)
 {
 	const HttpTime limit(totalTime() + (1000 * HttpTime(millis)));
@@ -302,6 +259,38 @@ HttpStatus HttpRequest::update(long millis)
 // Request Management Methods
 // ====================================
 
+HttpHandle HttpRequest::requestCancel(HttpHandle handle, HttpHandler * user_handler)
+{
+	HttpStatus status;
+	HttpHandle ret_handle(LLCORE_HTTP_HANDLE_INVALID);
+
+	HttpOpCancel * op = new HttpOpCancel(handle);
+	op->setReplyPath(mReplyQueue, user_handler);
+	mRequestQueue->addOp(op);			// transfer refcount as well
+
+	mLastReqStatus = status;
+	ret_handle = static_cast<HttpHandle>(op);
+	
+	return ret_handle;
+}
+
+
+HttpHandle HttpRequest::requestSetPriority(HttpHandle request, priority_t priority,
+										   HttpHandler * handler)
+{
+	HttpStatus status;
+	HttpHandle ret_handle(LLCORE_HTTP_HANDLE_INVALID);
+
+	HttpOpSetPriority * op = new HttpOpSetPriority(request, priority);
+	op->setReplyPath(mReplyQueue, handler);
+	mRequestQueue->addOp(op);			// transfer refcount as well
+
+	mLastReqStatus = status;
+	ret_handle = static_cast<HttpHandle>(op);
+	
+	return ret_handle;
+}
+
 
 // ====================================
 // Utility Methods
@@ -350,7 +339,27 @@ HttpHandle HttpRequest::requestStopThread(HttpHandler * user_handler)
 	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
 
 	HttpOpStop * op = new HttpOpStop();
-	op->setHandlers(mReplyQueue, mSelfHandler, user_handler);
+	op->setReplyPath(mReplyQueue, user_handler);
+	mRequestQueue->addOp(op);			// transfer refcount as well
+
+	mLastReqStatus = status;
+	handle = static_cast<HttpHandle>(op);
+
+	return handle;
+}
+
+// ====================================
+// Dynamic Policy Methods
+// ====================================
+
+HttpHandle HttpRequest::requestSetHttpProxy(const std::string & proxy, HttpHandler * handler)
+{
+	HttpStatus status;
+	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
+
+	HttpOpSetGet * op = new HttpOpSetGet();
+	op->setupSet(GP_HTTP_PROXY, proxy);
+	op->setReplyPath(mReplyQueue, handler);
 	mRequestQueue->addOp(op);			// transfer refcount as well
 
 	mLastReqStatus = status;
diff --git a/indra/llcorehttp/httprequest.h b/indra/llcorehttp/httprequest.h
index 01dbfba6dd..a953aa28d0 100644
--- a/indra/llcorehttp/httprequest.h
+++ b/indra/llcorehttp/httprequest.h
@@ -124,8 +124,8 @@ public:
 	/// @param opt		Enum of option to be set.
 	/// @param value	Desired value of option.
 	/// @return			Standard status code.
-	HttpStatus setPolicyGlobalOption(EGlobalPolicy opt, long value);
-	HttpStatus setPolicyGlobalOption(EGlobalPolicy opt, const std::string & value);
+	static HttpStatus setPolicyGlobalOption(EGlobalPolicy opt, long value);
+	static HttpStatus setPolicyGlobalOption(EGlobalPolicy opt, const std::string & value);
 
 	/// Create a new policy class into which requests can be made.
 	///
@@ -236,6 +236,32 @@ public:
 						   HttpHandler * handler);
 
 
+	///
+	/// @param	policy_id		Default or user-defined policy class under
+	///							which this request is to be serviced.
+	/// @param	priority		Standard priority scheme inherited from
+	///							Indra code base.
+	/// @param	url
+	/// @param	body			Byte stream to be sent as the body.  No
+	///							further encoding or escaping will be done
+	///							to the content.
+	/// @param	options			(optional)
+	/// @param	headers			(optional)
+	/// @param	handler			(optional)
+	/// @return					The handle of the request if successfully
+	///							queued or LLCORE_HTTP_HANDLE_INVALID if the
+	///							request could not be queued.  In the latter
+	///							case, @see getStatus() will return more info.
+	///
+	HttpHandle requestPut(policy_t policy_id,
+						  priority_t priority,
+						  const std::string & url,
+						  BufferArray * body,
+						  HttpOptions * options,
+						  HttpHeaders * headers,
+						  HttpHandler * handler);
+
+
 	/// Queue a NoOp request.
 	/// The request is queued and serviced by the working thread which
 	/// immediately processes it and returns the request to the reply
@@ -325,13 +351,20 @@ public:
 	HttpHandle requestStopThread(HttpHandler * handler);
 
 	/// @}
+	
+	/// @name DynamicPolicyMethods
+	///
+	/// @{
+
+	/// Request that a running transport pick up a new proxy setting.
+	/// An empty string will indicate no proxy is to be used.
+	HttpHandle requestSetHttpProxy(const std::string & proxy, HttpHandler * handler);
+
+    /// @}
 
 protected:
 	void generateNotification(HttpOperation * op);
 
-	class InternalHandler;
-	friend class InternalHandler;
-
 private:
 	/// @name InstanceData
 	///
@@ -339,7 +372,6 @@ private:
 	HttpStatus			mLastReqStatus;
 	HttpReplyQueue *	mReplyQueue;
 	HttpRequestQueue *	mRequestQueue;
-	InternalHandler *	mSelfHandler;
 	
 	/// @}
 	
diff --git a/indra/llcorehttp/tests/llcorehttp_test.cpp b/indra/llcorehttp/tests/llcorehttp_test.cpp
index f59361ab53..2b36d3a982 100644
--- a/indra/llcorehttp/tests/llcorehttp_test.cpp
+++ b/indra/llcorehttp/tests/llcorehttp_test.cpp
@@ -44,6 +44,8 @@
 #include "test_bufferarray.hpp"
 #include "test_httprequestqueue.hpp"
 
+#include "llproxy.h"
+
 unsigned long ssl_thread_id_callback(void);
 void ssl_locking_callback(int mode, int type, const char * file, int line);
 
@@ -91,11 +93,15 @@ void init_curl()
 		CRYPTO_set_locking_callback(ssl_locking_callback);
 		CRYPTO_set_id_callback(ssl_thread_id_callback);
 	}
+
+	LLProxy::getInstance();
 }
 
 
 void term_curl()
 {
+	LLProxy::cleanupClass();
+	
 	CRYPTO_set_locking_callback(NULL);
 	for (int i(0); i < ssl_mutex_count; ++i)
 	{
diff --git a/indra/llcorehttp/tests/test_httpoperation.hpp b/indra/llcorehttp/tests/test_httpoperation.hpp
index 6c3df1e9e3..17b1a96878 100644
--- a/indra/llcorehttp/tests/test_httpoperation.hpp
+++ b/indra/llcorehttp/tests/test_httpoperation.hpp
@@ -97,13 +97,12 @@ namespace tut
 
 		// Get some handlers
 		TestHandler * h1 = new TestHandler();
-		TestHandler * h2 = new TestHandler();
 		
 		// create a new ref counted object with an implicit reference
 		HttpOpNull * op = new HttpOpNull();
 
 		// Add the handlers
-		op->setHandlers(NULL, h1, h2);
+		op->setReplyPath(NULL, h1);
 
 		// Check ref count
 		ensure(op->getRefCount() == 1);
@@ -117,8 +116,6 @@ namespace tut
 		// release the handlers
 		delete h1;
 		h1 = NULL;
-		delete h2;
-		h2 = NULL;
 
 		ensure(mMemTotal == GetMemTotal());
 	}
diff --git a/indra/llcorehttp/tests/test_httprequest.hpp b/indra/llcorehttp/tests/test_httprequest.hpp
index 81f8fe4a85..61698f34d8 100644
--- a/indra/llcorehttp/tests/test_httprequest.hpp
+++ b/indra/llcorehttp/tests/test_httprequest.hpp
@@ -27,6 +27,7 @@
 #define TEST_LLCORE_HTTP_REQUEST_H_
 
 #include "httprequest.h"
+#include "bufferarray.h"
 #include "httphandler.h"
 #include "httpresponse.h"
 #include "_httpservice.h"
@@ -604,6 +605,244 @@ void HttpRequestTestObjectType::test<6>()
 	}
 }
 
+template <> template <>
+void HttpRequestTestObjectType::test<7>()
+{
+	ScopedCurlInit ready;
+
+	std::string url_base(get_base_url());
+	std::cerr << "Base:  "  << url_base << std::endl;
+	
+	set_test_name("HttpRequest PUT to real service");
+
+	// Handler can be stack-allocated *if* there are no dangling
+	// references to it after completion of this method.
+	// Create before memory record as the string copy will bump numbers.
+	TestHandler2 handler(this, "handler");
+		
+	// record the total amount of dynamically allocated memory
+	mMemTotal = GetMemTotal();
+	mHandlerCalls = 0;
+
+	HttpRequest * req = NULL;
+	BufferArray * body = new BufferArray;
+	
+	try
+	{
+		// Get singletons created
+		HttpRequest::createService();
+		
+		// Start threading early so that thread memory is invariant
+		// over the test.
+		HttpRequest::startThread();
+
+		// create a new ref counted object with an implicit reference
+		req = new HttpRequest();
+		ensure("Memory allocated on construction", mMemTotal < GetMemTotal());
+
+		// Issue a GET that *can* connect
+		static const char * body_text("Now is the time for all good men...");
+		body->append(body_text, strlen(body_text));
+		mStatus = HttpStatus(200);
+		HttpHandle handle = req->requestPut(HttpRequest::DEFAULT_POLICY_ID,
+											0U,
+											url_base,
+											body,
+											NULL,
+											NULL,
+											&handler);
+		ensure("Valid handle returned for ranged request", handle != LLCORE_HTTP_HANDLE_INVALID);
+
+		// Run the notification pump.
+		int count(0);
+		int limit(10);
+		while (count++ < limit && mHandlerCalls < 1)
+		{
+			req->update(1000);
+			usleep(100000);
+		}
+		ensure("Request executed in reasonable time", count < limit);
+		ensure("One handler invocation for request", mHandlerCalls == 1);
+
+		// Okay, request a shutdown of the servicing thread
+		mStatus = HttpStatus();
+		handle = req->requestStopThread(&handler);
+		ensure("Valid handle returned for second request", handle != LLCORE_HTTP_HANDLE_INVALID);
+	
+		// Run the notification pump again
+		count = 0;
+		limit = 10;
+		while (count++ < limit && mHandlerCalls < 2)
+		{
+			req->update(1000);
+			usleep(100000);
+		}
+		ensure("Second request executed in reasonable time", count < limit);
+		ensure("Second handler invocation", mHandlerCalls == 2);
+
+		// See that we actually shutdown the thread
+		count = 0;
+		limit = 10;
+		while (count++ < limit && ! HttpService::isStopped())
+		{
+			usleep(100000);
+		}
+		ensure("Thread actually stopped running", HttpService::isStopped());
+
+		// Lose the request body
+		body->release();
+		body = NULL;
+		
+		// release the request object
+		delete req;
+		req = NULL;
+
+		// Shut down service
+		HttpRequest::destroyService();
+	
+		ensure("Two handler calls on the way out", 2 == mHandlerCalls);
+
+#if defined(WIN32)
+		// Can only do this memory test on Windows.  On other platforms,
+		// the LL logging system holds on to memory and produces what looks
+		// like memory leaks...
+	
+		// printf("Old mem:  %d, New mem:  %d\n", mMemTotal, GetMemTotal());
+		ensure("Memory usage back to that at entry", mMemTotal == GetMemTotal());
+#endif
+	}
+	catch (...)
+	{
+		if (body)
+		{
+			body->release();
+		}
+		stop_thread(req);
+		delete req;
+		HttpRequest::destroyService();
+		throw;
+	}
+}
+
+template <> template <>
+void HttpRequestTestObjectType::test<8>()
+{
+	ScopedCurlInit ready;
+
+	std::string url_base(get_base_url());
+	std::cerr << "Base:  "  << url_base << std::endl;
+	
+	set_test_name("HttpRequest POST to real service");
+
+	// Handler can be stack-allocated *if* there are no dangling
+	// references to it after completion of this method.
+	// Create before memory record as the string copy will bump numbers.
+	TestHandler2 handler(this, "handler");
+		
+	// record the total amount of dynamically allocated memory
+	mMemTotal = GetMemTotal();
+	mHandlerCalls = 0;
+
+	HttpRequest * req = NULL;
+	BufferArray * body = new BufferArray;
+	
+	try
+	{
+		// Get singletons created
+		HttpRequest::createService();
+		
+		// Start threading early so that thread memory is invariant
+		// over the test.
+		HttpRequest::startThread();
+
+		// create a new ref counted object with an implicit reference
+		req = new HttpRequest();
+		ensure("Memory allocated on construction", mMemTotal < GetMemTotal());
+
+		// Issue a GET that *can* connect
+		static const char * body_text("Now is the time for all good men...");
+		body->append(body_text, strlen(body_text));
+		mStatus = HttpStatus(200);
+		HttpHandle handle = req->requestPost(HttpRequest::DEFAULT_POLICY_ID,
+											 0U,
+											 url_base,
+											 body,
+											 NULL,
+											 NULL,
+											 &handler);
+		ensure("Valid handle returned for ranged request", handle != LLCORE_HTTP_HANDLE_INVALID);
+
+		// Run the notification pump.
+		int count(0);
+		int limit(10);
+		while (count++ < limit && mHandlerCalls < 1)
+		{
+			req->update(1000);
+			usleep(100000);
+		}
+		ensure("Request executed in reasonable time", count < limit);
+		ensure("One handler invocation for request", mHandlerCalls == 1);
+
+		// Okay, request a shutdown of the servicing thread
+		mStatus = HttpStatus();
+		handle = req->requestStopThread(&handler);
+		ensure("Valid handle returned for second request", handle != LLCORE_HTTP_HANDLE_INVALID);
+	
+		// Run the notification pump again
+		count = 0;
+		limit = 10;
+		while (count++ < limit && mHandlerCalls < 2)
+		{
+			req->update(1000);
+			usleep(100000);
+		}
+		ensure("Second request executed in reasonable time", count < limit);
+		ensure("Second handler invocation", mHandlerCalls == 2);
+
+		// See that we actually shutdown the thread
+		count = 0;
+		limit = 10;
+		while (count++ < limit && ! HttpService::isStopped())
+		{
+			usleep(100000);
+		}
+		ensure("Thread actually stopped running", HttpService::isStopped());
+
+		// Lose the request body
+		body->release();
+		body = NULL;
+		
+		// release the request object
+		delete req;
+		req = NULL;
+
+		// Shut down service
+		HttpRequest::destroyService();
+	
+		ensure("Two handler calls on the way out", 2 == mHandlerCalls);
+
+#if defined(WIN32)
+		// Can only do this memory test on Windows.  On other platforms,
+		// the LL logging system holds on to memory and produces what looks
+		// like memory leaks...
+	
+		// printf("Old mem:  %d, New mem:  %d\n", mMemTotal, GetMemTotal());
+		ensure("Memory usage back to that at entry", mMemTotal == GetMemTotal());
+#endif
+	}
+	catch (...)
+	{
+		if (body)
+		{
+			body->release();
+		}
+		stop_thread(req);
+		delete req;
+		HttpRequest::destroyService();
+		throw;
+	}
+}
+
 }  // end namespace tut
 
 namespace
diff --git a/indra/llcorehttp/tests/test_llcorehttp_peer.py b/indra/llcorehttp/tests/test_llcorehttp_peer.py
index 3e200a5c19..8c3ad805b3 100644
--- a/indra/llcorehttp/tests/test_llcorehttp_peer.py
+++ b/indra/llcorehttp/tests/test_llcorehttp_peer.py
@@ -85,7 +85,15 @@ class TestHTTPRequestHandler(BaseHTTPRequestHandler):
 
     def do_POST(self):
         # Read the provided POST data.
-        self.answer(self.read())
+        # self.answer(self.read())
+        self.answer(dict(reply="success", status=200,
+                         reason=self.read()))
+
+    def do_PUT(self):
+        # Read the provided PUT data.
+        # self.answer(self.read())
+        self.answer(dict(reply="success", status=200,
+                         reason=self.read()))
 
     def answer(self, data):
         debug("%s.answer(%s): self.path = %r", self.__class__.__name__, data, self.path)
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 7a44415fba..e2c13e77e3 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -5358,6 +5358,7 @@ void CoreHttp::init()
 
 	mRequest = new LLCore::HttpRequest;
 
+	// Point to our certs or SSH/https: will fail on connect
 	status = mRequest->setPolicyGlobalOption(LLCore::HttpRequest::GP_CA_FILE,
 											 gDirUtilp->getCAFile());
 	if (! status)
@@ -5366,6 +5367,18 @@ void CoreHttp::init()
 						<< status.toString()
 						<< LL_ENDL;
 	}
+
+	// Establish HTTP Proxy.  "LLProxy" is a special string which directs
+	// the code to use LLProxy::applyProxySettings() to establish any
+	// HTTP or SOCKS proxy for http operations.
+	status = mRequest->setPolicyGlobalOption(LLCore::HttpRequest::GP_HTTP_PROXY,
+											 std::string("LLProxy"));
+	if (! status)
+	{
+		LL_ERRS("Init") << "Failed to set HTTP proxy for HTTP services.  Reason:  "
+						<< status.toString()
+						<< LL_ENDL;
+	}
 	
 	status = LLCore::HttpRequest::startThread();
 	if (! status)
-- 
cgit v1.3


From b08125a5874a89ce5210f8fb2c961ae17fb80fde Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Thu, 14 Jun 2012 16:31:48 -0400
Subject: LLMutex recursive lock, global & per-request tracing, simple GET
 request, LLProxy support, HttpOptions starting to work, HTTP resource waiting
 fixed. Non-LLThread-based threads need to do some registration or LLMutex
 locks taken out in these threads will not work as expected (SH-3154).  We'll
 get a better solution later, this fixes some things for now.  Tracing of
 operations now supported.  Global and per-request (via HttpOptions) tracing
 levels of [0..3].  The 2 and 3 levels use libcurl's VERBOSE mode combined
 with CURLOPT_DEBUGFUNCTION to stream high levels of detail into the log. 
 *Very* laggy but useful.  Simple GET request supported (no Range: header). 
 Really just a degenrate case of a ranged get but supplied an API anyway. 
 Global option to use the LLProxy interface to setup CURL handles for either
 socks5 or http proxy usage.  This isn't really the most encapsulated way to
 do this but a better solution will have to come later.  The wantHeaders and
 tracing options are now supported in HttpOptions giving per-request controls.
  Big refactoring of the HTTP resource waiter in lltexturefetch. What I was
 doing before wasn't correct.  Instead, I'm implementing the resource wait
 after the Semaphore model (though not using system semaphores).  So instead
 of having a sequence like:  SEND_HTTP_REQ -> WAIT_HTTP_RESOURCE ->
 SEND_HTTP_REQ, we now do WAIT_HTTP_RESOURCE -> WAIT_HTTP_RESOURCE2 (actual
 wait) -> SEND_HTTP_REQ.  Works well but the prioritized filling of the
 corehttp library needs some performance work later.

---
 indra/llcommon/llthread.cpp                 |   7 +
 indra/llcommon/llthread.h                   |   5 +
 indra/llcorehttp/_httplibcurl.cpp           |  24 ++-
 indra/llcorehttp/_httpoperation.cpp         |  15 +-
 indra/llcorehttp/_httpoperation.h           |   4 +
 indra/llcorehttp/_httpoprequest.cpp         | 271 +++++++++++++++++++++-------
 indra/llcorehttp/_httpoprequest.h           |  16 +-
 indra/llcorehttp/_httpopsetget.cpp          |   4 +-
 indra/llcorehttp/_httppolicy.cpp            |  21 ++-
 indra/llcorehttp/_httppolicy.h              |   5 +-
 indra/llcorehttp/_httppolicyglobal.cpp      |  52 ++++--
 indra/llcorehttp/_httppolicyglobal.h        |   6 +-
 indra/llcorehttp/_httpservice.cpp           |  18 +-
 indra/llcorehttp/httpoptions.cpp            |  18 +-
 indra/llcorehttp/httpoptions.h              |  14 +-
 indra/llcorehttp/httprequest.cpp            |  27 +++
 indra/llcorehttp/httprequest.h              |  75 +++++++-
 indra/llcorehttp/tests/test_httprequest.hpp | 228 ++++++++++++++++++++++-
 indra/newview/llappviewer.cpp               |  20 +-
 indra/newview/lltexturefetch.cpp            | 120 +++++++-----
 indra/newview/lltexturefetch.h              |   9 +
 indra/newview/lltextureview.cpp             |   5 +-
 22 files changed, 803 insertions(+), 161 deletions(-)

(limited to 'indra/newview/llappviewer.cpp')

diff --git a/indra/llcommon/llthread.cpp b/indra/llcommon/llthread.cpp
index a6ad6b125c..b27b64b26f 100644
--- a/indra/llcommon/llthread.cpp
+++ b/indra/llcommon/llthread.cpp
@@ -71,6 +71,13 @@ LL_COMMON_API void assert_main_thread()
 	}
 }
 
+void LLThread::registerThreadID()
+{
+#if !LL_DARWIN
+	sThreadID = ++sIDIter;
+#endif
+}
+
 //
 // Handed to the APR thread creation function
 //
diff --git a/indra/llcommon/llthread.h b/indra/llcommon/llthread.h
index b52e70ab2e..54af41ec59 100644
--- a/indra/llcommon/llthread.h
+++ b/indra/llcommon/llthread.h
@@ -88,6 +88,11 @@ public:
 
 	U32 getID() const { return mID; }
 
+	// Called by threads *not* created via LLThread to register some
+	// internal state used by LLMutex.  You must call this once early
+	// in the running thread to prevent collisions with the main thread.
+	static void registerThreadID();
+	
 private:
 	BOOL				mPaused;
 	
diff --git a/indra/llcorehttp/_httplibcurl.cpp b/indra/llcorehttp/_httplibcurl.cpp
index e134a28401..a176dd5b2a 100644
--- a/indra/llcorehttp/_httplibcurl.cpp
+++ b/indra/llcorehttp/_httplibcurl.cpp
@@ -159,6 +159,17 @@ void HttpLibcurl::addOp(HttpOpRequest * op)
 	curl_multi_add_handle(mMultiHandles[op->mReqPolicy], op->mCurlHandle);
 	op->mCurlActive = true;
 	
+	if (op->mTracing > 0)
+	{
+		HttpPolicy & policy(mService->getPolicy());
+		
+		LL_INFOS("CoreHttp") << "TRACE, ToActiveQueue, Handle:  "
+							 << static_cast<HttpHandle>(op)
+							 << ", Actives:  " << mActiveOps.size()
+							 << ", Readies:  " << policy.getReadyCount(op->mReqPolicy)
+							 << LL_ENDL;
+	}
+	
 	// On success, make operation active
 	mActiveOps.insert(op);
 }
@@ -190,10 +201,9 @@ bool HttpLibcurl::completeRequest(CURLM * multi_handle, CURL * handle, CURLcode
 	// Deactivate request
 	op->mCurlActive = false;
 
-	// Set final status of request
+	// Set final status of request if it hasn't failed by other mechanisms yet
 	if (op->mStatus)
 	{
-		// Only set if it hasn't failed by other mechanisms yet
 		op->mStatus = HttpStatus(HttpStatus::EXT_CURL_EASY, status);
 	}
 	if (op->mStatus)
@@ -209,6 +219,16 @@ bool HttpLibcurl::completeRequest(CURLM * multi_handle, CURL * handle, CURLcode
 	curl_easy_cleanup(handle);
 	op->mCurlHandle = NULL;
 
+	// Tracing
+	if (op->mTracing > 0)
+	{
+		LL_INFOS("CoreHttp") << "TRACE, RequestComplete, Handle:  "
+							 << static_cast<HttpHandle>(op)
+							 << ", Status:  " << op->mStatus.toHex()
+							 << LL_ENDL;
+	}
+
+	// Dispatch to next stage
 	HttpPolicy & policy(mService->getPolicy());
 	bool still_active(policy.stageAfterCompletion(op));
 
diff --git a/indra/llcorehttp/_httpoperation.cpp b/indra/llcorehttp/_httpoperation.cpp
index b5c58013d4..5a31bf90e7 100644
--- a/indra/llcorehttp/_httpoperation.cpp
+++ b/indra/llcorehttp/_httpoperation.cpp
@@ -34,6 +34,8 @@
 #include "_httpreplyqueue.h"
 #include "_httpservice.h"
 
+#include "lltimer.h"
+
 
 namespace LLCore
 {
@@ -49,8 +51,10 @@ HttpOperation::HttpOperation()
 	  mReplyQueue(NULL),
 	  mUserHandler(NULL),
 	  mReqPolicy(HttpRequest::DEFAULT_POLICY_ID),
-	  mReqPriority(0U)
+	  mReqPriority(0U),
+	  mTracing(0)
 {
+	mMetricCreated = totalTime();
 }
 
 
@@ -113,7 +117,7 @@ void HttpOperation::stageFromActive(HttpService *)
 	llassert_always(false);
 }
 
-	
+
 void HttpOperation::visitNotifier(HttpRequest *)
 {
 	if (mUserHandler)
@@ -138,6 +142,13 @@ HttpStatus HttpOperation::cancel()
 
 void HttpOperation::addAsReply()
 {
+	if (mTracing > 0)
+	{
+		LL_INFOS("CoreHttp") << "TRACE, ToReplyQueue, Handle:  "
+							 << static_cast<HttpHandle>(this)
+							 << LL_ENDL;
+	}
+	
 	if (mReplyQueue)
 	{
 		addRef();
diff --git a/indra/llcorehttp/_httpoperation.h b/indra/llcorehttp/_httpoperation.h
index c93aa2def9..de4939a0ac 100644
--- a/indra/llcorehttp/_httpoperation.h
+++ b/indra/llcorehttp/_httpoperation.h
@@ -110,6 +110,10 @@ public:
 
 	// Reply Data
 	HttpStatus					mStatus;
+
+	// Tracing, debug and metrics
+	HttpTime					mMetricCreated;
+	int							mTracing;
 };  // end class HttpOperation
 
 
diff --git a/indra/llcorehttp/_httpoprequest.cpp b/indra/llcorehttp/_httpoprequest.cpp
index e2550d057e..f78971d8f2 100644
--- a/indra/llcorehttp/_httpoprequest.cpp
+++ b/indra/llcorehttp/_httpoprequest.cpp
@@ -63,6 +63,16 @@ int parse_content_range_header(char * buffer,
 							   unsigned int * last,
 							   unsigned int * length);
 
+
+// Take data from libcurl's CURLOPT_DEBUGFUNCTION callback and
+// escape and format it for a tracing line in logging.  Absolutely
+// anything including NULs can be in the data.  If @scrub is true,
+// non-printing or non-ascii characters are replaced with spaces
+// otherwise a %XX form of escaping is used.
+void escape_libcurl_debug_data(char * buffer, size_t len, bool scrub,
+							   std::string & safe_line);
+
+
 #if defined(WIN32)
 
 // Not available on windows where the legacy strtok interface
@@ -78,11 +88,6 @@ namespace LLCore
 {
 
 
-// ==================================
-// HttpOpRequest
-// ==================================
-
-
 HttpOpRequest::HttpOpRequest()
 	: HttpOperation(),
 	  mProcFlags(0U),
@@ -237,6 +242,19 @@ HttpStatus HttpOpRequest::cancel()
 }
 
 
+HttpStatus HttpOpRequest::setupGet(HttpRequest::policy_t policy_id,
+								   HttpRequest::priority_t priority,
+								   const std::string & url,
+								   HttpOptions * options,
+								   HttpHeaders * headers)
+{
+	setupCommon(policy_id, priority, url, NULL, options, headers);
+	mReqMethod = HOR_GET;
+	
+	return HttpStatus();
+}
+
+
 HttpStatus HttpOpRequest::setupGetByteRange(HttpRequest::policy_t policy_id,
 											HttpRequest::priority_t priority,
 											const std::string & url,
@@ -245,30 +263,16 @@ HttpStatus HttpOpRequest::setupGetByteRange(HttpRequest::policy_t policy_id,
 											HttpOptions * options,
 											HttpHeaders * headers)
 {
-	HttpStatus status;
-
-	mProcFlags = 0;
-	mReqPolicy = policy_id;
-	mReqPriority = priority;
+	setupCommon(policy_id, priority, url, NULL, options, headers);
 	mReqMethod = HOR_GET;
-	mReqURL = url;
 	mReqOffset = offset;
 	mReqLength = len;
 	if (offset || len)
 	{
 		mProcFlags |= PF_SCAN_RANGE_HEADER;
 	}
-	if (headers && ! mReqHeaders)
-	{
-		headers->addRef();
-		mReqHeaders = headers;
-	}
-	if (options && ! mReqOptions)
-	{
-		mReqOptions = new HttpOptions(*options);
-	}
 	
-	return status;
+	return HttpStatus();
 }
 
 
@@ -279,29 +283,10 @@ HttpStatus HttpOpRequest::setupPost(HttpRequest::policy_t policy_id,
 									HttpOptions * options,
 									HttpHeaders * headers)
 {
-	HttpStatus status;
-
-	mProcFlags = 0;
-	mReqPolicy = policy_id;
-	mReqPriority = priority;
+	setupCommon(policy_id, priority, url, body, options, headers);
 	mReqMethod = HOR_POST;
-	mReqURL = url;
-	if (body)
-	{
-		body->addRef();
-		mReqBody = body;
-	}
-	if (headers && ! mReqHeaders)
-	{
-		headers->addRef();
-		mReqHeaders = headers;
-	}
-	if (options && ! mReqOptions)
-	{
-		mReqOptions = new HttpOptions(*options);
-	}
 	
-	return status;
+	return HttpStatus();
 }
 
 
@@ -312,12 +297,23 @@ HttpStatus HttpOpRequest::setupPut(HttpRequest::policy_t policy_id,
 								   HttpOptions * options,
 								   HttpHeaders * headers)
 {
-	HttpStatus status;
+	setupCommon(policy_id, priority, url, body, options, headers);
+	mReqMethod = HOR_PUT;
+	
+	return HttpStatus();
+}
 
+
+void HttpOpRequest::setupCommon(HttpRequest::policy_t policy_id,
+								HttpRequest::priority_t priority,
+								const std::string & url,
+								BufferArray * body,
+								HttpOptions * options,
+								HttpHeaders * headers)
+{
 	mProcFlags = 0;
 	mReqPolicy = policy_id;
 	mReqPriority = priority;
-	mReqMethod = HOR_PUT;
 	mReqURL = url;
 	if (body)
 	{
@@ -331,10 +327,14 @@ HttpStatus HttpOpRequest::setupPut(HttpRequest::policy_t policy_id,
 	}
 	if (options && ! mReqOptions)
 	{
-		mReqOptions = new HttpOptions(*options);
+		options->addRef();
+		mReqOptions = options;
+		if (options->getWantHeaders())
+		{
+			mProcFlags |= PF_SAVE_HEADERS;
+		}
+		mTracing = (std::max)(mTracing, llclamp(options->getTrace(), 0, 3));
 	}
-	
-	return status;
 }
 
 
@@ -394,30 +394,29 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 	curl_easy_setopt(mCurlHandle, CURLOPT_SSL_VERIFYHOST, 0);
 
 	const std::string * opt_value(NULL);
-	if (policy.get(HttpRequest::GP_CA_PATH, opt_value))
+	long opt_long(0L);
+	policy.get(HttpRequest::GP_LLPROXY, &opt_long);
+	if (opt_long)
 	{
-		curl_easy_setopt(mCurlHandle, CURLOPT_CAPATH, opt_value->c_str());
+		// Use the viewer-based thread-safe API which has a
+		// fast/safe check for proxy enable.  Would like to
+		// encapsulate this someway...
+		LLProxy::getInstance()->applyProxySettings(mCurlHandle);
 	}
-	if (policy.get(HttpRequest::GP_CA_FILE, opt_value))
+	else if (policy.get(HttpRequest::GP_HTTP_PROXY, &opt_value))
 	{
-		curl_easy_setopt(mCurlHandle, CURLOPT_CAINFO, opt_value->c_str());
+		// *TODO:  This is fine for now but get fuller socks/
+		// authentication thing going later....
+		curl_easy_setopt(mCurlHandle, CURLOPT_PROXY, opt_value->c_str());
+		curl_easy_setopt(mCurlHandle, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
 	}
-	if (policy.get(HttpRequest::GP_HTTP_PROXY, opt_value))
+	if (policy.get(HttpRequest::GP_CA_PATH, &opt_value))
 	{
-		if (*opt_value == "LLProxy")
-		{
-			// Use the viewer-based thread-safe API which has a
-			// fast/safe check for proxy enable.  Would like to
-			// encapsulate this someway...
-			LLProxy::getInstance()->applyProxySettings(mCurlHandle);
-		}
-		else
-		{
-			// *TODO:  This is fine for now but get fuller socks/
-			// authentication thing going later....
-			curl_easy_setopt(mCurlHandle, CURLOPT_PROXY, opt_value->c_str());
-			curl_easy_setopt(mCurlHandle, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
-		}
+		curl_easy_setopt(mCurlHandle, CURLOPT_CAPATH, opt_value->c_str());
+	}
+	if (policy.get(HttpRequest::GP_CA_FILE, &opt_value))
+	{
+		curl_easy_setopt(mCurlHandle, CURLOPT_CAINFO, opt_value->c_str());
 	}
 	
 	switch (mReqMethod)
@@ -463,6 +462,14 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
 		// *FIXME:  fail out here
 		break;
 	}
+
+	// Tracing
+	if (mTracing > 1)
+	{
+		curl_easy_setopt(mCurlHandle, CURLOPT_VERBOSE, 1);
+		curl_easy_setopt(mCurlHandle, CURLOPT_DEBUGDATA, mCurlHandle);
+		curl_easy_setopt(mCurlHandle, CURLOPT_DEBUGFUNCTION, debugCallback);
+	}
 	
 	// There's a CURLOPT for this now...
 	if ((mReqOffset || mReqLength) && HOR_GET == mReqMethod)
@@ -621,6 +628,101 @@ size_t HttpOpRequest::headerCallback(void * data, size_t size, size_t nmemb, voi
 	return hdr_size;
 }
 
+
+int HttpOpRequest::debugCallback(CURL * handle, curl_infotype info, char * buffer, size_t len, void * userdata)
+{
+	HttpOpRequest * op(NULL);
+	curl_easy_getinfo(handle, CURLINFO_PRIVATE, &op);
+	// *FIXME:  check the pointer
+
+	std::string safe_line;
+	std::string tag;
+	bool logit(false);
+	len = (std::min)(len, size_t(256));					// Keep things reasonable in all cases
+	
+	switch (info)
+	{
+	case CURLINFO_TEXT:
+		if (op->mTracing > 1)
+		{
+			tag = "TEXT";
+			escape_libcurl_debug_data(buffer, len, true, safe_line);
+			logit = true;
+		}
+		break;
+			
+	case CURLINFO_HEADER_IN:
+		if (op->mTracing > 1)
+		{
+			tag = "HEADERIN";
+			escape_libcurl_debug_data(buffer, len, true, safe_line);
+			logit = true;
+		}
+		break;
+			
+	case CURLINFO_HEADER_OUT:
+		if (op->mTracing > 1)
+		{
+			tag = "HEADEROUT";
+			escape_libcurl_debug_data(buffer, len, true, safe_line);
+			logit = true;
+		}
+		break;
+			
+	case CURLINFO_DATA_IN:
+		if (op->mTracing > 1)
+		{
+			tag = "DATAIN";
+			logit = true;
+			if (op->mTracing > 2)
+			{
+				escape_libcurl_debug_data(buffer, len, false, safe_line);
+			}
+			else
+			{
+				std::ostringstream out;
+				out << len << " Bytes";
+				safe_line = out.str();
+			}
+		}
+		break;
+			
+	case CURLINFO_DATA_OUT:
+		if (op->mTracing > 1)
+		{
+			tag = "DATAOUT";
+			logit = true;
+			if (op->mTracing > 2)
+			{
+				escape_libcurl_debug_data(buffer, len, false, safe_line);
+			}
+			else
+			{
+				std::ostringstream out;
+				out << len << " Bytes";
+				safe_line = out.str();
+			}
+		}
+		break;
+			
+	default:
+		logit = false;
+		break;
+	}
+
+	if (logit)
+	{
+		LL_INFOS("CoreHttp") << "TRACE, LibcurlDebug, Handle:  "
+							 << static_cast<HttpHandle>(op)
+							 << ", Type:  " << tag
+							 << ", Data:  " << safe_line
+							 << LL_ENDL;
+	}
+		
+	return 0;
+}
+
+
 }   // end namespace LLCore
 
 
@@ -694,6 +796,43 @@ char *strtok_r(char *str, const char *delim, char ** savestate)
 
 #endif
 
+
+void escape_libcurl_debug_data(char * buffer, size_t len, bool scrub, std::string & safe_line)
+{
+	std::string out;
+	len = (std::min)(len, size_t(200));
+	out.reserve(3 * len);
+	for (int i(0); i < len; ++i)
+	{
+		unsigned char uc(static_cast<unsigned char>(buffer[i]));
+
+		if (uc < 32 || uc > 126)
+		{
+			if (scrub)
+			{
+				out.append(1, ' ');
+			}
+			else
+			{
+				static const char hex[] = "0123456789ABCDEF";
+				char convert[4];
+
+				convert[0] = '%';
+				convert[1] = hex[(uc >> 4) % 16];
+				convert[2] = hex[uc % 16];
+				convert[3] = '\0';
+				out.append(convert);
+			}
+		}
+		else
+		{
+			out.append(1, buffer[i]);
+		}
+	}
+	safe_line.swap(out);
+}
+
+
 }  // end anonymous namespace
 
 		
diff --git a/indra/llcorehttp/_httpoprequest.h b/indra/llcorehttp/_httpoprequest.h
index 80893beb40..fc2301057c 100644
--- a/indra/llcorehttp/_httpoprequest.h
+++ b/indra/llcorehttp/_httpoprequest.h
@@ -76,6 +76,12 @@ public:
 			
 public:
 	// Setup Methods
+	HttpStatus setupGet(HttpRequest::policy_t policy_id,
+						HttpRequest::priority_t priority,
+						const std::string & url,
+						HttpOptions * options,
+						HttpHeaders * headers);
+	
 	HttpStatus setupGetByteRange(HttpRequest::policy_t policy_id,
 								 HttpRequest::priority_t priority,
 								 const std::string & url,
@@ -103,15 +109,23 @@ public:
 	virtual HttpStatus cancel();
 
 protected:
+	void setupCommon(HttpRequest::policy_t policy_id,
+					 HttpRequest::priority_t priority,
+					 const std::string & url,
+					 BufferArray * body,
+					 HttpOptions * options,
+					 HttpHeaders * headers);
+	
 	static size_t writeCallback(void * data, size_t size, size_t nmemb, void * userdata);
 	static size_t readCallback(void * data, size_t size, size_t nmemb, void * userdata);
 	static size_t headerCallback(void * data, size_t size, size_t nmemb, void * userdata);
+	static int debugCallback(CURL *, curl_infotype info, char * buffer, size_t len, void * userdata);
 
 protected:
 	unsigned int		mProcFlags;
 	static const unsigned int	PF_SCAN_RANGE_HEADER = 0x00000001U;
 	static const unsigned int	PF_SAVE_HEADERS = 0x00000002U;
-	
+
 public:
 	// Request data
 	EMethod				mReqMethod;
diff --git a/indra/llcorehttp/_httpopsetget.cpp b/indra/llcorehttp/_httpopsetget.cpp
index 21e058b2be..c1357f9ae5 100644
--- a/indra/llcorehttp/_httpopsetget.cpp
+++ b/indra/llcorehttp/_httpopsetget.cpp
@@ -89,8 +89,8 @@ void HttpOpSetGet::stageFromRequest(HttpService * service)
 	}
 	if (mStatus)
 	{
-		const std::string * value;
-		if ((mStatus = pol_opt.get(setting, value)))
+		const std::string * value(NULL);
+		if ((mStatus = pol_opt.get(setting, &value)))
 		{
 			mStrValue = *value;
 		}
diff --git a/indra/llcorehttp/_httppolicy.cpp b/indra/llcorehttp/_httppolicy.cpp
index 8ee3f88658..0e08d88276 100644
--- a/indra/llcorehttp/_httppolicy.cpp
+++ b/indra/llcorehttp/_httppolicy.cpp
@@ -107,6 +107,12 @@ void HttpPolicy::retryOp(HttpOpRequest * op)
 	LL_WARNS("CoreHttp") << "URL op retry #" << op->mPolicyRetries
 						 << " being scheduled for " << delta << " uSecs from now."
 						 << LL_ENDL;
+	if (op->mTracing > 0)
+	{
+		LL_INFOS("CoreHttp") << "TRACE, ToRetryQueue, Handle:  "
+							 << static_cast<HttpHandle>(op)
+							 << LL_ENDL;
+	}
 	mState[policy_class].mRetryQueue.push(op);
 }
 
@@ -224,8 +230,8 @@ bool HttpPolicy::stageAfterCompletion(HttpOpRequest * op)
 	}
 	else if (op->mPolicyRetries)
 	{
-		LL_WARNS("CoreHttp") << "URL op succeeded after " << op->mPolicyRetries << " retries."
-							 << LL_ENDL;
+		LL_DEBUGS("CoreHttp") << "URL op succeeded after " << op->mPolicyRetries << " retries."
+							  << LL_ENDL;
 	}
 
 	op->stageFromActive(mService);
@@ -234,4 +240,15 @@ bool HttpPolicy::stageAfterCompletion(HttpOpRequest * op)
 }
 
 
+int HttpPolicy::getReadyCount(HttpRequest::policy_t policy_class)
+{
+	if (policy_class < HttpRequest::POLICY_CLASS_LIMIT)
+	{
+		return (mState[policy_class].mReadyQueue.size()
+				+ mState[policy_class].mRetryQueue.size());
+	}
+	return 0;
+}
+
+
 }  // end namespace LLCore
diff --git a/indra/llcorehttp/_httppolicy.h b/indra/llcorehttp/_httppolicy.h
index 73c22bab78..4114f64848 100644
--- a/indra/llcorehttp/_httppolicy.h
+++ b/indra/llcorehttp/_httppolicy.h
@@ -97,7 +97,10 @@ public:
 		}
 
 	void setPolicies(const HttpPolicyGlobal & global);
-			
+
+	// Get ready counts for a particular class
+	int getReadyCount(HttpRequest::policy_t policy_class);
+	
 protected:
 	struct State
 	{
diff --git a/indra/llcorehttp/_httppolicyglobal.cpp b/indra/llcorehttp/_httppolicyglobal.cpp
index d95d73cfba..6b1de38fd6 100644
--- a/indra/llcorehttp/_httppolicyglobal.cpp
+++ b/indra/llcorehttp/_httppolicyglobal.cpp
@@ -33,7 +33,9 @@ namespace LLCore
 
 HttpPolicyGlobal::HttpPolicyGlobal()
 	: mSetMask(0UL),
-	  mConnectionLimit(32L)
+	  mConnectionLimit(32L),
+	  mTrace(0),
+	  mUseLLProxy(0)
 {}
 
 
@@ -50,6 +52,8 @@ HttpPolicyGlobal & HttpPolicyGlobal::operator=(const HttpPolicyGlobal & other)
 		mCAPath = other.mCAPath;
 		mCAFile = other.mCAFile;
 		mHttpProxy = other.mHttpProxy;
+		mTrace = other.mTrace;
+		mUseLLProxy = other.mUseLLProxy;
 	}
 	return *this;
 }
@@ -63,6 +67,14 @@ HttpStatus HttpPolicyGlobal::set(HttpRequest::EGlobalPolicy opt, long value)
 		mConnectionLimit = value;
 		break;
 
+	case HttpRequest::GP_TRACE:
+		mTrace = llclamp(value, 0L, 3L);
+		break;
+
+	case HttpRequest::GP_LLPROXY:
+		mUseLLProxy = llclamp(value, 0L, 1L);
+		break;
+
 	default:
 		return HttpStatus(HttpStatus::LLCORE, HE_INVALID_ARG);
 	}
@@ -97,54 +109,64 @@ HttpStatus HttpPolicyGlobal::set(HttpRequest::EGlobalPolicy opt, const std::stri
 }
 
 
-HttpStatus HttpPolicyGlobal::get(HttpRequest::EGlobalPolicy opt, long & value)
+HttpStatus HttpPolicyGlobal::get(HttpRequest::EGlobalPolicy opt, long * value)
 {
 	static const HttpStatus not_set(HttpStatus::LLCORE, HE_OPT_NOT_SET);
+	long * src(NULL);
 	
 	switch (opt)
 	{
 	case HttpRequest::GP_CONNECTION_LIMIT:
-		if (! (mSetMask & (1UL << int(opt))))
-			return not_set;
-		value = mConnectionLimit;
+		src = &mConnectionLimit;
+		break;
+
+	case HttpRequest::GP_TRACE:
+		src = &mTrace;
+		break;
+
+	case HttpRequest::GP_LLPROXY:
+		src = &mUseLLProxy;
 		break;
 
 	default:
 		return HttpStatus(HttpStatus::LLCORE, HE_INVALID_ARG);
 	}
 
+	if (! (mSetMask & (1UL << int(opt))))
+		return not_set;
+
+	*value = *src;
 	return HttpStatus();
 }
 
 
-HttpStatus HttpPolicyGlobal::get(HttpRequest::EGlobalPolicy opt, const std::string *& value)
+HttpStatus HttpPolicyGlobal::get(HttpRequest::EGlobalPolicy opt, const std::string ** value)
 {
 	static const HttpStatus not_set(HttpStatus::LLCORE, HE_OPT_NOT_SET);
+	const std::string * src(NULL);
 
 	switch (opt)
 	{
 	case HttpRequest::GP_CA_PATH:
-		if (! (mSetMask & (1UL << int(opt))))
-			return not_set;
-		value = &mCAPath;
+		src = &mCAPath;
 		break;
 
 	case HttpRequest::GP_CA_FILE:
-		if (! (mSetMask & (1UL << int(opt))))
-			return not_set;
-		value = &mCAFile;
+		src = &mCAFile;
 		break;
 
 	case HttpRequest::GP_HTTP_PROXY:
-		if (! (mSetMask & (1UL << int(opt))))
-			return not_set;
-		value = &mHttpProxy;
+		src = &mHttpProxy;
 		break;
 
 	default:
 		return HttpStatus(HttpStatus::LLCORE, HE_INVALID_ARG);
 	}
 	
+	if (! (mSetMask & (1UL << int(opt))))
+		return not_set;
+
+	*value = src;
 	return HttpStatus();
 }
 
diff --git a/indra/llcorehttp/_httppolicyglobal.h b/indra/llcorehttp/_httppolicyglobal.h
index f4bb4d4b25..a50d0e4188 100644
--- a/indra/llcorehttp/_httppolicyglobal.h
+++ b/indra/llcorehttp/_httppolicyglobal.h
@@ -48,8 +48,8 @@ private:
 public:
 	HttpStatus set(HttpRequest::EGlobalPolicy opt, long value);
 	HttpStatus set(HttpRequest::EGlobalPolicy opt, const std::string & value);
-	HttpStatus get(HttpRequest::EGlobalPolicy opt, long & value);
-	HttpStatus get(HttpRequest::EGlobalPolicy opt, const std::string *& value);
+	HttpStatus get(HttpRequest::EGlobalPolicy opt, long * value);
+	HttpStatus get(HttpRequest::EGlobalPolicy opt, const std::string ** value);
 	
 public:
 	unsigned long		mSetMask;
@@ -57,6 +57,8 @@ public:
 	std::string			mCAPath;
 	std::string			mCAFile;
 	std::string			mHttpProxy;
+	long				mTrace;
+	long				mUseLLProxy;
 };  // end class HttpPolicyGlobal
 
 }  // end namespace LLCore
diff --git a/indra/llcorehttp/_httpservice.cpp b/indra/llcorehttp/_httpservice.cpp
index 920a3f3b6d..beba8f08f4 100644
--- a/indra/llcorehttp/_httpservice.cpp
+++ b/indra/llcorehttp/_httpservice.cpp
@@ -36,6 +36,7 @@
 #include "_thread.h"
 
 #include "lltimer.h"
+#include "llthread.h"
 
 
 // Tuning parameters
@@ -186,8 +187,10 @@ void HttpService::shutdown()
 void HttpService::threadRun(LLCoreInt::HttpThread * thread)
 {
 	boost::this_thread::disable_interruption di;
-	ELoopSpeed loop(REQUEST_SLEEP);
+
+	LLThread::registerThreadID();
 	
+	ELoopSpeed loop(REQUEST_SLEEP);
 	while (! mExitRequested)
 	{
 		loop = processRequestQueue(loop);
@@ -226,6 +229,19 @@ HttpService::ELoopSpeed HttpService::processRequestQueue(ELoopSpeed loop)
 		// Process operation
 		if (! mExitRequested)
 		{
+			// Setup for subsequent tracing
+			long tracing(0);
+			mPolicy->getGlobalOptions().get(HttpRequest::GP_TRACE, &tracing);
+			op->mTracing = (std::max)(op->mTracing, int(tracing));
+
+			if (op->mTracing > 0)
+			{
+				LL_INFOS("CoreHttp") << "TRACE, FromRequestQueue, Handle:  "
+									 << static_cast<HttpHandle>(op)
+									 << LL_ENDL;
+			}
+
+			// Stage
 			op->stageFromRequest(this);
 		}
 				
diff --git a/indra/llcorehttp/httpoptions.cpp b/indra/llcorehttp/httpoptions.cpp
index 15b505f5bf..155fbda7f1 100644
--- a/indra/llcorehttp/httpoptions.cpp
+++ b/indra/llcorehttp/httpoptions.cpp
@@ -33,13 +33,15 @@ namespace LLCore
 
 HttpOptions::HttpOptions()
 	: RefCounted(true),
-	  mWantHeaders(false)
+	  mWantHeaders(false),
+	  mTracing(0)
 {}
 
 
 HttpOptions::HttpOptions(const HttpOptions & rhs)
 	: RefCounted(true),
-	  mWantHeaders(rhs.mWantHeaders)
+	  mWantHeaders(rhs.mWantHeaders),
+	  mTracing(rhs.mTracing)
 {}
 
 
@@ -47,4 +49,16 @@ HttpOptions::~HttpOptions()
 {}
 
 
+void HttpOptions::setWantHeaders()
+{
+	mWantHeaders = true;
+}
+
+
+void HttpOptions::setTrace(long level)
+{
+	mTracing = int(level);
+}
+
+
 }   // end namespace LLCore
diff --git a/indra/llcorehttp/httpoptions.h b/indra/llcorehttp/httpoptions.h
index 267a982dd5..0b9dfdc1de 100644
--- a/indra/llcorehttp/httpoptions.h
+++ b/indra/llcorehttp/httpoptions.h
@@ -67,11 +67,21 @@ protected:
 	void operator=(const HttpOptions &);		// Not defined
 
 public:
+	void		setWantHeaders();
+	bool		getWantHeaders() const
+		{
+			return mWantHeaders;
+		}
+	
+	void		setTrace(long level);
+	int			getTrace() const
+		{
+			return mTracing;
+		}
 	
 protected:
-	// *TODO:  add some options
 	bool		mWantHeaders;
-	
+	long		int mTracing;
 }; // end class HttpOptions
 
 
diff --git a/indra/llcorehttp/httprequest.cpp b/indra/llcorehttp/httprequest.cpp
index 089eee76f3..2036ecfd1c 100644
--- a/indra/llcorehttp/httprequest.cpp
+++ b/indra/llcorehttp/httprequest.cpp
@@ -135,6 +135,33 @@ HttpStatus HttpRequest::getStatus() const
 }
 
 
+HttpHandle HttpRequest::requestGet(policy_t policy_id,
+								   priority_t priority,
+								   const std::string & url,
+								   HttpOptions * options,
+								   HttpHeaders * headers,
+								   HttpHandler * user_handler)
+{
+	HttpStatus status;
+	HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
+
+	HttpOpRequest * op = new HttpOpRequest();
+	if (! (status = op->setupGet(policy_id, priority, url, options, headers)))
+	{
+		op->release();
+		mLastReqStatus = status;
+		return handle;
+	}
+	op->setReplyPath(mReplyQueue, user_handler);
+	mRequestQueue->addOp(op);			// transfers refcount
+	
+	mLastReqStatus = status;
+	handle = static_cast<HttpHandle>(op);
+	
+	return handle;
+}
+
+
 HttpHandle HttpRequest::requestGetByteRange(policy_t policy_id,
 											priority_t priority,
 											const std::string & url,
diff --git a/indra/llcorehttp/httprequest.h b/indra/llcorehttp/httprequest.h
index a953aa28d0..4e78ed3719 100644
--- a/indra/llcorehttp/httprequest.h
+++ b/indra/llcorehttp/httprequest.h
@@ -111,10 +111,43 @@ public:
 		/// Maximum number of connections the library will use to
 		/// perform operations.  This is somewhat soft as the underlying
 		/// transport will cache some connections (up to 5).
-		GP_CONNECTION_LIMIT,		///< Takes long giving number of connections
-		GP_CA_PATH,					///< System path/directory where SSL certs are stored.
-		GP_CA_FILE,					///< System path/file containing certs.
-		GP_HTTP_PROXY				///< String giving host/port to use for HTTP proxy
+
+		/// A long value setting the maximum number of connections
+		/// allowed over all policy classes.  Note that this will be
+		/// a somewhat soft value.  There may be an additional five
+		/// connections per policy class depending upon runtime
+		/// behavior.
+		GP_CONNECTION_LIMIT,
+
+		/// String containing a system-appropriate directory name
+		/// where SSL certs are stored.
+		GP_CA_PATH,
+
+		/// String giving a full path to a file containing SSL certs.
+		GP_CA_FILE,
+
+		/// String of host/port to use as simple HTTP proxy.  This is
+		/// going to change in the future into something more elaborate
+		/// that may support richer schemes.
+		GP_HTTP_PROXY,
+
+		/// Long value that if non-zero enables the use of the
+		/// traditional LLProxy code for http/socks5 support.  If
+		/// enabled, has priority over GP_HTTP_PROXY.
+		GP_LLPROXY,
+
+		/// Long value setting the logging trace level for the
+		/// library.  Possible values are:
+		/// 0 - No tracing (default)
+		/// 1 - Basic tracing of request start, stop and major events.
+		/// 2 - Connection, header and payload size information from
+		///     HTTP transactions.
+		/// 3 - Partial logging of payload itself.
+		///
+		/// These values are also used in the trace modes for
+		/// individual requests in HttpOptions.  Also be aware that
+		/// tracing tends to impact performance of the viewer.
+		GP_TRACE
 	};
 
 	/// Set a parameter on a global policy option.  Calls
@@ -133,7 +166,7 @@ public:
 	///					the class in other methods.  If -1, an error
 	///					occurred and @see getStatus() may provide more
 	///					detail on the reason.
-	policy_t createPolicyClass();
+	static policy_t createPolicyClass();
 
 	enum EClassPolicy
 	{
@@ -157,7 +190,7 @@ public:
 	/// @param opt				Enum of option to be set.
 	/// @param value			Desired value of option.
 	/// @return					Standard status code.
-	HttpStatus setPolicyClassOption(policy_t policy_id, EClassPolicy opt, long value);
+	static HttpStatus setPolicyClassOption(policy_t policy_id, EClassPolicy opt, long value);
 
 	/// @}
 
@@ -176,6 +209,36 @@ public:
 	///
 	HttpStatus getStatus() const;
 
+	/// Queue a full HTTP GET request to be issued for entire entity.
+	/// The request is queued and serviced by the working thread and
+	/// notification of completion delivered to the optional HttpHandler
+	/// argument during @see update() calls.
+	///
+	/// With a valid handle returned, it can be used to reference the
+	/// request in other requests (like cancellation) and will be an
+	/// argument when any HttpHandler object is invoked.
+	///
+	/// @param	policy_id		Default or user-defined policy class under
+	///							which this request is to be serviced.
+	/// @param	priority		Standard priority scheme inherited from
+	///							Indra code base (U32-type scheme).
+	/// @param	url
+	/// @param	options			(optional)
+	/// @param	headers			(optional)
+	/// @param	handler			(optional)
+	/// @return					The handle of the request if successfully
+	///							queued or LLCORE_HTTP_HANDLE_INVALID if the
+	///							request could not be queued.  In the latter
+	///							case, @see getStatus() will return more info.
+	///
+	HttpHandle requestGet(policy_t policy_id,
+						  priority_t priority,
+						  const std::string & url,
+						  HttpOptions * options,
+						  HttpHeaders * headers,
+						  HttpHandler * handler);
+
+
 	/// Queue a full HTTP GET request to be issued with a 'Range' header.
 	/// The request is queued and serviced by the working thread and
 	/// notification of completion delivered to the optional HttpHandler
diff --git a/indra/llcorehttp/tests/test_httprequest.hpp b/indra/llcorehttp/tests/test_httprequest.hpp
index 61698f34d8..5b04796c8a 100644
--- a/indra/llcorehttp/tests/test_httprequest.hpp
+++ b/indra/llcorehttp/tests/test_httprequest.hpp
@@ -395,7 +395,7 @@ void HttpRequestTestObjectType::test<5>()
 {
 	ScopedCurlInit ready;
 
-	set_test_name("HttpRequest GET + Stop execution");
+	set_test_name("HttpRequest GET to dead port + Stop execution");
 
 	// Handler can be stack-allocated *if* there are no dangling
 	// references to it after completion of this method.
@@ -496,6 +496,7 @@ void HttpRequestTestObjectType::test<5>()
 	}
 }
 
+
 template <> template <>
 void HttpRequestTestObjectType::test<6>()
 {
@@ -517,6 +518,114 @@ void HttpRequestTestObjectType::test<6>()
 
 	HttpRequest * req = NULL;
 
+	try
+	{
+		// Get singletons created
+		HttpRequest::createService();
+		
+		// Start threading early so that thread memory is invariant
+		// over the test.
+		HttpRequest::startThread();
+
+		// create a new ref counted object with an implicit reference
+		req = new HttpRequest();
+		ensure("Memory allocated on construction", mMemTotal < GetMemTotal());
+
+		// Issue a GET that *can* connect
+		mStatus = HttpStatus(200);
+		HttpHandle handle = req->requestGet(HttpRequest::DEFAULT_POLICY_ID,
+											0U,
+											url_base,
+											NULL,
+											NULL,
+											&handler);
+		ensure("Valid handle returned for ranged request", handle != LLCORE_HTTP_HANDLE_INVALID);
+
+		// Run the notification pump.
+		int count(0);
+		int limit(10);
+		while (count++ < limit && mHandlerCalls < 1)
+		{
+			req->update(1000);
+			usleep(100000);
+		}
+		ensure("Request executed in reasonable time", count < limit);
+		ensure("One handler invocation for request", mHandlerCalls == 1);
+
+		// Okay, request a shutdown of the servicing thread
+		mStatus = HttpStatus();
+		handle = req->requestStopThread(&handler);
+		ensure("Valid handle returned for second request", handle != LLCORE_HTTP_HANDLE_INVALID);
+	
+		// Run the notification pump again
+		count = 0;
+		limit = 10;
+		while (count++ < limit && mHandlerCalls < 2)
+		{
+			req->update(1000);
+			usleep(100000);
+		}
+		ensure("Second request executed in reasonable time", count < limit);
+		ensure("Second handler invocation", mHandlerCalls == 2);
+
+		// See that we actually shutdown the thread
+		count = 0;
+		limit = 10;
+		while (count++ < limit && ! HttpService::isStopped())
+		{
+			usleep(100000);
+		}
+		ensure("Thread actually stopped running", HttpService::isStopped());
+	
+		// release the request object
+		delete req;
+		req = NULL;
+
+		// Shut down service
+		HttpRequest::destroyService();
+	
+		ensure("Two handler calls on the way out", 2 == mHandlerCalls);
+
+#if defined(WIN32)
+		// Can only do this memory test on Windows.  On other platforms,
+		// the LL logging system holds on to memory and produces what looks
+		// like memory leaks...
+	
+		// printf("Old mem:  %d, New mem:  %d\n", mMemTotal, GetMemTotal());
+		ensure("Memory usage back to that at entry", mMemTotal == GetMemTotal());
+#endif
+	}
+	catch (...)
+	{
+		stop_thread(req);
+		delete req;
+		HttpRequest::destroyService();
+		throw;
+	}
+}
+
+
+template <> template <>
+void HttpRequestTestObjectType::test<7>()
+{
+	ScopedCurlInit ready;
+
+	std::string url_base(get_base_url());
+	std::cerr << "Base:  "  << url_base << std::endl;
+	
+	set_test_name("HttpRequest GET with Range: header to real service");
+
+	// Handler can be stack-allocated *if* there are no dangling
+	// references to it after completion of this method.
+	// Create before memory record as the string copy will bump numbers.
+	TestHandler2 handler(this, "handler");
+		
+	// record the total amount of dynamically allocated memory
+	mMemTotal = GetMemTotal();
+	mHandlerCalls = 0;
+
+	HttpRequest * req = NULL;
+
 	try
 	{
 		// Get singletons created
@@ -605,8 +714,9 @@ void HttpRequestTestObjectType::test<6>()
 	}
 }
 
+
 template <> template <>
-void HttpRequestTestObjectType::test<7>()
+void HttpRequestTestObjectType::test<8>()
 {
 	ScopedCurlInit ready;
 
@@ -725,7 +835,7 @@ void HttpRequestTestObjectType::test<7>()
 }
 
 template <> template <>
-void HttpRequestTestObjectType::test<8>()
+void HttpRequestTestObjectType::test<9>()
 {
 	ScopedCurlInit ready;
 
@@ -843,6 +953,118 @@ void HttpRequestTestObjectType::test<8>()
 	}
 }
 
+template <> template <>
+void HttpRequestTestObjectType::test<10>()
+{
+	ScopedCurlInit ready;
+
+	std::string url_base(get_base_url());
+	std::cerr << "Base:  "  << url_base << std::endl;
+	
+	set_test_name("HttpRequest GET with some tracing");
+
+	// Handler can be stack-allocated *if* there are no dangling
+	// references to it after completion of this method.
+	// Create before memory record as the string copy will bump numbers.
+	TestHandler2 handler(this, "handler");
+		
+	// record the total amount of dynamically allocated memory
+	mMemTotal = GetMemTotal();
+	mHandlerCalls = 0;
+
+	HttpRequest * req = NULL;
+
+	try
+	{
+		// Get singletons created
+		HttpRequest::createService();
+
+		// Enable tracing
+		HttpRequest::setPolicyGlobalOption(LLCore::HttpRequest::GP_TRACE, 2);
+
+		// Start threading early so that thread memory is invariant
+		// over the test.
+		HttpRequest::startThread();
+
+		// create a new ref counted object with an implicit reference
+		req = new HttpRequest();
+		ensure("Memory allocated on construction", mMemTotal < GetMemTotal());
+
+		// Issue a GET that *can* connect
+		mStatus = HttpStatus(200);
+		HttpHandle handle = req->requestGetByteRange(HttpRequest::DEFAULT_POLICY_ID,
+													 0U,
+													 url_base,
+													 0,
+													 0,
+													 NULL,
+													 NULL,
+													 &handler);
+		ensure("Valid handle returned for ranged request", handle != LLCORE_HTTP_HANDLE_INVALID);
+
+		// Run the notification pump.
+		int count(0);
+		int limit(10);
+		while (count++ < limit && mHandlerCalls < 1)
+		{
+			req->update(1000);
+			usleep(100000);
+		}
+		ensure("Request executed in reasonable time", count < limit);
+		ensure("One handler invocation for request", mHandlerCalls == 1);
+
+		// Okay, request a shutdown of the servicing thread
+		mStatus = HttpStatus();
+		handle = req->requestStopThread(&handler);
+		ensure("Valid handle returned for second request", handle != LLCORE_HTTP_HANDLE_INVALID);
+	
+		// Run the notification pump again
+		count = 0;
+		limit = 10;
+		while (count++ < limit && mHandlerCalls < 2)
+		{
+			req->update(1000);
+			usleep(100000);
+		}
+		ensure("Second request executed in reasonable time", count < limit);
+		ensure("Second handler invocation", mHandlerCalls == 2);
+
+		// See that we actually shutdown the thread
+		count = 0;
+		limit = 10;
+		while (count++ < limit && ! HttpService::isStopped())
+		{
+			usleep(100000);
+		}
+		ensure("Thread actually stopped running", HttpService::isStopped());
+	
+		// release the request object
+		delete req;
+		req = NULL;
+
+		// Shut down service
+		HttpRequest::destroyService();
+	
+		ensure("Two handler calls on the way out", 2 == mHandlerCalls);
+
+#if defined(WIN32)
+		// Can only do this memory test on Windows.  On other platforms,
+		// the LL logging system holds on to memory and produces what looks
+		// like memory leaks...
+	
+		// printf("Old mem:  %d, New mem:  %d\n", mMemTotal, GetMemTotal());
+		ensure("Memory usage back to that at entry", mMemTotal == GetMemTotal());
+#endif
+	}
+	catch (...)
+	{
+		stop_thread(req);
+		delete req;
+		HttpRequest::destroyService();
+		throw;
+	}
+}
+
 }  // end namespace tut
 
 namespace
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index e2c13e77e3..430dd89c3e 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -5356,11 +5356,9 @@ void CoreHttp::init()
 						<< LL_ENDL;
 	}
 
-	mRequest = new LLCore::HttpRequest;
-
 	// Point to our certs or SSH/https: will fail on connect
-	status = mRequest->setPolicyGlobalOption(LLCore::HttpRequest::GP_CA_FILE,
-											 gDirUtilp->getCAFile());
+	status = LLCore::HttpRequest::setPolicyGlobalOption(LLCore::HttpRequest::GP_CA_FILE,
+														gDirUtilp->getCAFile());
 	if (! status)
 	{
 		LL_ERRS("Init") << "Failed to set CA File for HTTP services.  Reason:  "
@@ -5371,15 +5369,22 @@ void CoreHttp::init()
 	// Establish HTTP Proxy.  "LLProxy" is a special string which directs
 	// the code to use LLProxy::applyProxySettings() to establish any
 	// HTTP or SOCKS proxy for http operations.
-	status = mRequest->setPolicyGlobalOption(LLCore::HttpRequest::GP_HTTP_PROXY,
-											 std::string("LLProxy"));
+	status = LLCore::HttpRequest::setPolicyGlobalOption(LLCore::HttpRequest::GP_LLPROXY, 1);
 	if (! status)
 	{
 		LL_ERRS("Init") << "Failed to set HTTP proxy for HTTP services.  Reason:  "
 						<< status.toString()
 						<< LL_ENDL;
 	}
-	
+
+	// Tracing levels for library & libcurl (note that 2 & 3 are beyond spammy):
+	// 0 - None
+	// 1 - Basic start, stop simple transitions
+	// 2 - libcurl CURLOPT_VERBOSE mode with brief lines
+	// 3 - with partial data content
+	status = LLCore::HttpRequest::setPolicyGlobalOption(LLCore::HttpRequest::GP_TRACE, 0);
+
+	// Kick the thread
 	status = LLCore::HttpRequest::startThread();
 	if (! status)
 	{
@@ -5388,6 +5393,7 @@ void CoreHttp::init()
 						<< LL_ENDL;
 	}
 
+	mRequest = new LLCore::HttpRequest;
 }
 
 
diff --git a/indra/newview/lltexturefetch.cpp b/indra/newview/lltexturefetch.cpp
index f5e7540e85..664af02f78 100644
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
@@ -431,6 +431,22 @@ private:
 	void lockWorkMutex() { mWorkMutex.lock(); }
 	void unlockWorkMutex() { mWorkMutex.unlock(); }
 
+	// Locks:  Mw
+	void acquireHttpSemaphore()
+		{
+			llassert(! mHttpHasResource);
+			mHttpHasResource = true;
+			--mFetcher->mHttpSemaphore;
+		}
+
+	// Locks:  Mw
+	void releaseHttpSemaphore()
+		{
+			llassert(mHttpHasResource);
+			mHttpHasResource = false;
+			++mFetcher->mHttpSemaphore;
+		}
+	
 private:
 	enum e_state // mState
 	{
@@ -444,8 +460,9 @@ private:
 		CACHE_POST,
 		LOAD_FROM_NETWORK,
 		LOAD_FROM_SIMULATOR,
-		SEND_HTTP_REQ,					// Commit to sending as HTTP
 		WAIT_HTTP_RESOURCE,				// Waiting for HTTP resources
+		WAIT_HTTP_RESOURCE2,			// Waiting for HTTP resources
+		SEND_HTTP_REQ,					// Commit to sending as HTTP
 		WAIT_HTTP_REQ,					// Request sent, wait for completion
 		DECODE_IMAGE,
 		DECODE_IMAGE_UPDATE,
@@ -532,7 +549,7 @@ private:
 	bool					mHttpActive;				// Active request to http library
 	unsigned int			mHttpReplySize;
 	unsigned int			mHttpReplyOffset;
-	bool					mHttpReleased;				// Has been released from resource wait once
+	bool					mHttpHasResource;			// Counts against Fetcher's mHttpSemaphore
 };
 
 //////////////////////////////////////////////////////////////////////////////
@@ -768,8 +785,9 @@ const char* LLTextureFetchWorker::sStateDescs[] = {
 	"CACHE_POST",
 	"LOAD_FROM_NETWORK",
 	"LOAD_FROM_SIMULATOR",
-	"SEND_HTTP_REQ",
 	"WAIT_HTTP_RESOURCE",
+	"WAIT_HTTP_RESOURCE2",
+	"SEND_HTTP_REQ",
 	"WAIT_HTTP_REQ",
 	"DECODE_IMAGE",
 	"DECODE_IMAGE_UPDATE",
@@ -836,7 +854,7 @@ LLTextureFetchWorker::LLTextureFetchWorker(LLTextureFetch* fetcher,
 	  mHttpActive(false),
 	  mHttpReplySize(0U),
 	  mHttpReplyOffset(0U),
-	  mHttpReleased(true)
+	  mHttpHasResource(false)
 {
 	mCanUseNET = mUrl.empty() ;
 
@@ -860,6 +878,10 @@ LLTextureFetchWorker::~LLTextureFetchWorker()
 	llassert_always(!haveWork());
 
 	lockWorkMutex();													// +Mw (should be useless)
+	if (mHttpHasResource)
+	{
+		releaseHttpSemaphore();
+	}
 	if (mHttpActive)
 	{
 		// Issue a cancel on a live request...
@@ -1126,7 +1148,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 					llwarns << "Unknown URL Type: " << mUrl << llendl;
 				}
 				setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
-				mState = SEND_HTTP_REQ;
+				mState = WAIT_HTTP_RESOURCE;
 			}
 			else
 			{
@@ -1223,7 +1245,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 		}
 		if (mCanUseHTTP && !mUrl.empty())
 		{
-			mState = SEND_HTTP_REQ;
+			mState = WAIT_HTTP_RESOURCE;
 			setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
 			if(mWriteToCacheState != NOT_WRITE)
 			{
@@ -1287,31 +1309,38 @@ bool LLTextureFetchWorker::doWork(S32 param)
 		return false;
 	}
 	
-	if (mState == SEND_HTTP_REQ)
+	if (mState == WAIT_HTTP_RESOURCE)
 	{
-		if (! mCanUseHTTP)
-		{
-			return true; // abort
-		}
-
 		// NOTE:
 		// control the number of the http requests issued for:
 		// 1, not openning too many file descriptors at the same time;
 		// 2, control the traffic of http so udp gets bandwidth.
 		//
-		if (! mHttpReleased)
+		// If it looks like we're busy, keep this request here.
+		// Otherwise, advance into the HTTP states.
+		if (mFetcher->mHttpSemaphore <= 0 || mFetcher->getHttpWaitersCount())
 		{
-			// If this request hasn't been released before and it looks like
-			// we're busy, put this request into resource wait and allow something
-			// else to come to the front.
-			if (mFetcher->getNumHTTPRequests() >= HTTP_REQUESTS_IN_QUEUE_HIGH_WATER ||
-				mFetcher->getHttpWaitersCount())
-			{
-				mState = WAIT_HTTP_RESOURCE;
-				setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority);
-				mFetcher->addHttpWaiter(this->mID);
-				return false;
-			}
+			mState = WAIT_HTTP_RESOURCE2;
+			setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority);
+			mFetcher->addHttpWaiter(this->mID);
+			return false;
+		}
+		mState = SEND_HTTP_REQ;
+		acquireHttpSemaphore();
+	}
+
+	if (mState == WAIT_HTTP_RESOURCE2)
+	{
+		// Just idle it if we make it to the head...
+		return false;
+	}
+	
+	if (mState == SEND_HTTP_REQ)
+	{
+		if (! mCanUseHTTP)
+		{
+			releaseHttpSemaphore();
+			return true; // abort
 		}
 
 		mFetcher->removeFromNetworkQueue(this, false);
@@ -1327,10 +1356,12 @@ bool LLTextureFetchWorker::doWork(S32 param)
 					// We already have all the data, just decode it
 					mLoadedDiscard = mFormattedImage->getDiscardLevel();
 					mState = DECODE_IMAGE;
+					releaseHttpSemaphore();
 					return false;
 				}
 				else
 				{
+					releaseHttpSemaphore();
 					return true; // abort.
 				}
 			}
@@ -1365,6 +1396,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 		{
 			llwarns << "HTTP GET request failed for " << mID << llendl;
 			resetFormattedData();
+			releaseHttpSemaphore();
 			return true; // failed
 		}
 
@@ -1377,13 +1409,6 @@ bool LLTextureFetchWorker::doWork(S32 param)
 		// fall through
 	}
 	
-	if (mState == WAIT_HTTP_RESOURCE)
-	{
-		// Nothing to do until releaseHttpWaiters() puts us back
-		// into the flow...
-		return false;
-	}
-	
 	if (mState == WAIT_HTTP_REQ)
 	{
 		if (mLoaded)
@@ -1401,6 +1426,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 						mState = INIT;
 						mCanUseHTTP = false;
 						setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
+						releaseHttpSemaphore();
 						return false;
 					}
 				}
@@ -1423,12 +1449,14 @@ bool LLTextureFetchWorker::doWork(S32 param)
 					// Use available data
 					mLoadedDiscard = mFormattedImage->getDiscardLevel();
 					mState = DECODE_IMAGE;
+					releaseHttpSemaphore();
 					return false; 
 				}
 
 				// Fail harder
 				resetFormattedData();
 				mState = DONE;
+				releaseHttpSemaphore();
 				return true; // failed
 			}
 			
@@ -1443,6 +1471,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 
 				// abort.
 				mState = DONE;
+				releaseHttpSemaphore();
 				return true;
 			}
 
@@ -1491,6 +1520,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 				mWriteToCacheState = SHOULD_WRITE ;
 			}
 			setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
+			releaseHttpSemaphore();
 			return false;
 		}
 		else
@@ -2137,7 +2167,8 @@ LLTextureFetch::LLTextureFetch(LLTextureCache* cache, LLImageDecodeThread* image
 	  mQAMode(qa_mode),
 	  mHttpRequest(NULL),
 	  mHttpOptions(NULL),
-	  mHttpHeaders(NULL)
+	  mHttpHeaders(NULL),
+	  mHttpSemaphore(HTTP_REQUESTS_IN_QUEUE_HIGH_WATER)
 {
 	mMaxBandwidth = gSavedSettings.getF32("ThrottleBandwidthKBPS");
 	mTextureInfo.setUpLogging(gSavedSettings.getBOOL("LogTextureDownloadsToViewerLog"), gSavedSettings.getBOOL("LogTextureDownloadsToSimulator"), gSavedSettings.getU32("TextureLoggingThreshold"));
@@ -3155,12 +3186,11 @@ void LLTextureFetch::removeHttpWaiter(const LLUUID & tid)
 // Locks:  -Mw (must not hold any worker when called)
 void LLTextureFetch::releaseHttpWaiters()
 {
-	if (HTTP_REQUESTS_IN_QUEUE_LOW_WATER < getNumHTTPRequests())
+	if (mHttpSemaphore < HTTP_REQUESTS_IN_QUEUE_LOW_WATER)
 		return;
 
 	// Quickly make a copy of all the LLUIDs.  Get off the
 	// mutex as early as possible.
-
 	typedef std::vector<LLUUID> uuid_vec_t;
 	uuid_vec_t tids;
 
@@ -3171,13 +3201,12 @@ void LLTextureFetch::releaseHttpWaiters()
 			return;
 
 		const size_t limit(mHttpWaitResource.size());
-		tids.resize(limit);
-		wait_http_res_queue_t::iterator iter(mHttpWaitResource.begin());
-		for (int i(0);
-			 i < limit && mHttpWaitResource.end() != iter;
-			 ++i, ++iter)
+		tids.reserve(limit);
+		for (wait_http_res_queue_t::iterator iter(mHttpWaitResource.begin());
+			 mHttpWaitResource.end() != iter;
+			 ++iter)
 		{
-			tids[i] = *iter;
+			tids.push_back(*iter);
 		}
 	}																	// -Mfnq
 
@@ -3196,28 +3225,29 @@ void LLTextureFetch::releaseHttpWaiters()
 			tids2.insert(worker);
 		}
 	}
+	tids.clear();
 
 	// Release workers up to the high water mark.  Since we aren't
 	// holding any locks at this point, we can be in competition
 	// with other callers.  Do defensive things like getting
 	// refreshed counts of requests and checking if someone else
 	// has moved any worker state around....
-	tids.clear();
 	for (worker_set_t::iterator iter2(tids2.begin());
-		 tids2.end() != iter2 && 0 < (HTTP_REQUESTS_IN_QUEUE_HIGH_WATER - getNumHTTPRequests());
+		 tids2.end() != iter2 && mHttpSemaphore > 0;
 		 ++iter2)
 	{
 		LLTextureFetchWorker * worker(* iter2);
 
 		worker->lockWorkMutex();										// +Mw
-		if (LLTextureFetchWorker::WAIT_HTTP_RESOURCE != worker->mState)
+		if (LLTextureFetchWorker::WAIT_HTTP_RESOURCE2 != worker->mState)
 		{
 			worker->unlockWorkMutex();									// -Mw
 			continue;
 		}
-		worker->mHttpReleased = true;
+
 		worker->mState = LLTextureFetchWorker::SEND_HTTP_REQ;
 		worker->setPriority(LLWorkerThread::PRIORITY_HIGH | worker->mWorkPriority);
+		worker->acquireHttpSemaphore();
 		worker->unlockWorkMutex();										// -Mw
 
 		removeHttpWaiter(worker->mID);
@@ -3456,7 +3486,7 @@ TFReqSendMetrics::doWork(LLTextureFetch * fetcher)
 	}
 
 	// In QA mode, Metrics submode, log the result for ease of testing
-	if (fetcher->isQAMode() || true)
+	if (fetcher->isQAMode())
 	{
 		LL_INFOS("Textures") << merged_llsd << LL_ENDL;
 	}
diff --git a/indra/newview/lltexturefetch.h b/indra/newview/lltexturefetch.h
index 4ee13d171e..50e3181623 100644
--- a/indra/newview/lltexturefetch.h
+++ b/indra/newview/lltexturefetch.h
@@ -312,6 +312,15 @@ private:
 	LLCore::HttpOptions *		mHttpOptions;							// Ttf
 	LLCore::HttpHeaders *		mHttpHeaders;							// Ttf
 
+	// We use a resource semaphore to keep HTTP requests in
+	// WAIT_HTTP_RESOURCE2 if there aren't sufficient slots in the
+	// transport.  This keeps them near where they can be cheaply
+	// reprioritized rather than dumping them all across a thread
+	// where it's more expensive to get at them.  Requests in either
+	// SEND_HTTP_REQ or WAIT_HTTP_REQ charge against the semaphore
+	// and tracking state transitions is critical to liveness.
+	int							mHttpSemaphore;							// Ttf
+	
 	typedef std::set<LLUUID> wait_http_res_queue_t;
 	wait_http_res_queue_t		mHttpWaitResource;						// Mfnq
 	
diff --git a/indra/newview/lltextureview.cpp b/indra/newview/lltextureview.cpp
index 5f1d7829ed..bb1535d23d 100644
--- a/indra/newview/lltextureview.cpp
+++ b/indra/newview/lltextureview.cpp
@@ -234,15 +234,16 @@ void LLTextureBar::draw()
 		{ "DSK", LLColor4::blue },	// CACHE_POST
 		{ "NET", LLColor4::green },	// LOAD_FROM_NETWORK
 		{ "SIM", LLColor4::green },	// LOAD_FROM_SIMULATOR
+		{ "HTW", LLColor4::green },	// WAIT_HTTP_RESOURCE
+		{ "HTW", LLColor4::green },	// WAIT_HTTP_RESOURCE2
 		{ "REQ", LLColor4::yellow },// SEND_HTTP_REQ
-		{ "HTW", LLColor4::green },	// WAIT_HTTP_RES
 		{ "HTP", LLColor4::green },	// WAIT_HTTP_REQ
 		{ "DEC", LLColor4::yellow },// DECODE_IMAGE
 		{ "DEC", LLColor4::green }, // DECODE_IMAGE_UPDATE
 		{ "WRT", LLColor4::purple },// WRITE_TO_CACHE
 		{ "WRT", LLColor4::orange },// WAIT_ON_WRITE
 		{ "END", LLColor4::red },   // DONE
-#define LAST_STATE 13
+#define LAST_STATE 14
 		{ "CRE", LLColor4::magenta }, // LAST_STATE+1
 		{ "FUL", LLColor4::green }, // LAST_STATE+2
 		{ "BAD", LLColor4::red }, // LAST_STATE+3
-- 
cgit v1.3


From bc72acbfd2410e01946375bcfa29cf37a7c01c17 Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Tue, 10 Jul 2012 18:50:21 -0400
Subject: SH-3244  Syscall avoidance in HttpRequest::update() method Well,
 achieved that by doing work in bulk when needed.  But turned into some
 additional things.  Change timebase from mS to uS as, well, things are headed
 that way.  Implement an HttpReplyQueue::fetchAll method (advertised one,
 hadn't implemented it).

---
 indra/llcorehttp/_httpreplyqueue.cpp            | 20 +++++++++++
 indra/llcorehttp/_httprequestqueue.cpp          |  7 ++--
 indra/llcorehttp/examples/http_texture_load.cpp |  2 +-
 indra/llcorehttp/httprequest.cpp                | 40 +++++++++++++++++----
 indra/llcorehttp/httprequest.h                  |  7 ++--
 indra/llcorehttp/tests/test_httprequest.hpp     | 48 ++++++++++++-------------
 indra/newview/llappviewer.cpp                   |  2 +-
 indra/newview/lltexturefetch.cpp                | 19 ++++------
 8 files changed, 92 insertions(+), 53 deletions(-)

(limited to 'indra/newview/llappviewer.cpp')

diff --git a/indra/llcorehttp/_httpreplyqueue.cpp b/indra/llcorehttp/_httpreplyqueue.cpp
index a354ed7e10..558b7bdee9 100644
--- a/indra/llcorehttp/_httpreplyqueue.cpp
+++ b/indra/llcorehttp/_httpreplyqueue.cpp
@@ -84,4 +84,24 @@ HttpOperation * HttpReplyQueue::fetchOp()
 	return result;
 }
 
+
+void HttpReplyQueue::fetchAll(OpContainer & ops)
+{
+	// Not valid putting something back on the queue...
+	llassert_always(ops.empty());
+
+	{
+		HttpScopedLock lock(mQueueMutex);
+
+		if (! mQueue.empty())
+		{
+			mQueue.swap(ops);
+		}
+	}
+
+	// Caller also acquires the reference counts on each op.
+	return;
+}
+
+
 }  // end namespace LLCore
diff --git a/indra/llcorehttp/_httprequestqueue.cpp b/indra/llcorehttp/_httprequestqueue.cpp
index 9acac665a9..c16966d078 100644
--- a/indra/llcorehttp/_httprequestqueue.cpp
+++ b/indra/llcorehttp/_httprequestqueue.cpp
@@ -120,10 +120,9 @@ HttpOperation * HttpRequestQueue::fetchOp(bool wait)
 
 void HttpRequestQueue::fetchAll(bool wait, OpContainer & ops)
 {
-	// Note:  Should probably test whether we're empty or not here.
-	// A target passed in with entries is likely also carrying
-	// reference counts and we're going to leak something.
-	ops.clear();
+	// Not valid putting something back on the queue...
+	llassert_always(ops.empty());
+
 	{
 		HttpScopedLock lock(mQueueMutex);
 
diff --git a/indra/llcorehttp/examples/http_texture_load.cpp b/indra/llcorehttp/examples/http_texture_load.cpp
index e5951e8415..bcb322bd5c 100644
--- a/indra/llcorehttp/examples/http_texture_load.cpp
+++ b/indra/llcorehttp/examples/http_texture_load.cpp
@@ -244,7 +244,7 @@ int main(int argc, char** argv)
 	int passes(0);
 	while (! ws.reload(hr))
 	{
-		hr->update(5000);
+		hr->update(5000000);
 		ms_sleep(2);
 		if (0 == (++passes % 200))
 		{
diff --git a/indra/llcorehttp/httprequest.cpp b/indra/llcorehttp/httprequest.cpp
index 3a55a849b9..9b739a8825 100644
--- a/indra/llcorehttp/httprequest.cpp
+++ b/indra/llcorehttp/httprequest.cpp
@@ -296,17 +296,43 @@ HttpHandle HttpRequest::requestNoOp(HttpHandler * user_handler)
 }
 
 
-HttpStatus HttpRequest::update(long millis)
+HttpStatus HttpRequest::update(long usecs)
 {
-	const HttpTime limit(totalTime() + (1000 * HttpTime(millis)));
 	HttpOperation * op(NULL);
-	while (limit >= totalTime() && (op = mReplyQueue->fetchOp()))
+	
+	if (usecs)
 	{
-		// Process operation
-		op->visitNotifier(this);
+		const HttpTime limit(totalTime() + HttpTime(usecs));
+		while (limit >= totalTime() && (op = mReplyQueue->fetchOp()))
+		{
+			// Process operation
+			op->visitNotifier(this);
 		
-		// We're done with the operation
-		op->release();
+			// We're done with the operation
+			op->release();
+		}
+	}
+	else
+	{
+		// Same as above, just no time limit
+		HttpReplyQueue::OpContainer replies;
+		mReplyQueue->fetchAll(replies);
+		if (! replies.empty())
+		{
+			for (HttpReplyQueue::OpContainer::iterator iter(replies.begin());
+				 replies.end() != iter;
+				 ++iter)
+			{
+				// Swap op pointer for NULL;
+				op = *iter; *iter = NULL;	
+			
+				// Process operation
+				op->visitNotifier(this);
+		
+				// We're done with the operation
+				op->release();
+			}
+		}
 	}
 	
 	return HttpStatus();
diff --git a/indra/llcorehttp/httprequest.h b/indra/llcorehttp/httprequest.h
index 134a61b618..9dd53f4483 100644
--- a/indra/llcorehttp/httprequest.h
+++ b/indra/llcorehttp/httprequest.h
@@ -341,13 +341,14 @@ public:
 	/// are expected to return 'quickly' and do any significant processing
 	/// outside of the notification callback to onCompleted().
 	///
-	/// @param	millis			Maximum number of wallclock milliseconds to
+	/// @param	usecs			Maximum number of wallclock microseconds to
 	///							spend in the call.  As hinted at above, this
 	///							is partly a function of application code so it's
-	///							a soft limit.
+	///							a soft limit.  A '0' value will run without
+	///							time limit.
 	///
 	/// @return					Standard status code.
-	HttpStatus update(long millis);
+	HttpStatus update(long usecs);
 
 	/// @}
 	
diff --git a/indra/llcorehttp/tests/test_httprequest.hpp b/indra/llcorehttp/tests/test_httprequest.hpp
index 914f35ec3d..ba7c757af4 100644
--- a/indra/llcorehttp/tests/test_httprequest.hpp
+++ b/indra/llcorehttp/tests/test_httprequest.hpp
@@ -260,7 +260,7 @@ void HttpRequestTestObjectType::test<3>()
 		int limit(20);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("Request executed in reasonable time", count < limit);
@@ -275,7 +275,7 @@ void HttpRequestTestObjectType::test<3>()
 		limit = 100;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
@@ -358,8 +358,8 @@ void HttpRequestTestObjectType::test<4>()
 		int limit(20);
 		while (count++ < limit && mHandlerCalls < 2)
 		{
-			req1->update(1000);
-			req2->update(1000);
+			req1->update(1000000);
+			req2->update(1000000);
 			usleep(100000);
 		}
 		ensure("Request executed in reasonable time", count < limit);
@@ -375,8 +375,8 @@ void HttpRequestTestObjectType::test<4>()
 		limit = 100;
 		while (count++ < limit && mHandlerCalls < 3)
 		{
-			req1->update(1000);
-			req2->update(1000);
+			req1->update(1000000);
+			req2->update(1000000);
 			usleep(100000);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
@@ -459,7 +459,7 @@ void HttpRequestTestObjectType::test<5>()
 		int limit(10);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("NoOp notification received", mHandlerCalls == 1);
@@ -535,7 +535,7 @@ void HttpRequestTestObjectType::test<6>()
 		int limit(10);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("No notifications received", mHandlerCalls == 0);
@@ -616,7 +616,7 @@ void HttpRequestTestObjectType::test<7>()
 		int limit(50);				// With one retry, should fail quickish
 		while (count++ < limit && mHandlerCalls < 1)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("Request executed in reasonable time", count < limit);
@@ -632,7 +632,7 @@ void HttpRequestTestObjectType::test<7>()
 		limit = 100;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
@@ -733,7 +733,7 @@ void HttpRequestTestObjectType::test<8>()
 		int limit(10);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("Request executed in reasonable time", count < limit);
@@ -749,7 +749,7 @@ void HttpRequestTestObjectType::test<8>()
 		limit = 10;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
@@ -843,7 +843,7 @@ void HttpRequestTestObjectType::test<9>()
 		int limit(10);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("Request executed in reasonable time", count < limit);
@@ -859,7 +859,7 @@ void HttpRequestTestObjectType::test<9>()
 		limit = 10;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
@@ -955,7 +955,7 @@ void HttpRequestTestObjectType::test<10>()
 		int limit(10);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("Request executed in reasonable time", count < limit);
@@ -971,7 +971,7 @@ void HttpRequestTestObjectType::test<10>()
 		limit = 10;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
@@ -1074,7 +1074,7 @@ void HttpRequestTestObjectType::test<11>()
 		int limit(10);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("Request executed in reasonable time", count < limit);
@@ -1090,7 +1090,7 @@ void HttpRequestTestObjectType::test<11>()
 		limit = 10;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
@@ -1194,7 +1194,7 @@ void HttpRequestTestObjectType::test<12>()
 		int limit(10);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("Request executed in reasonable time", count < limit);
@@ -1210,7 +1210,7 @@ void HttpRequestTestObjectType::test<12>()
 		limit = 10;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
@@ -1316,7 +1316,7 @@ void HttpRequestTestObjectType::test<13>()
 		int limit(10);
 		while (count++ < limit && mHandlerCalls < 1)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("Request executed in reasonable time", count < limit);
@@ -1333,7 +1333,7 @@ void HttpRequestTestObjectType::test<13>()
 		limit = 10;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
@@ -1435,7 +1435,7 @@ void HttpRequestTestObjectType::test<14>()
 		int limit(50);				// With one retry, should fail quickish
 		while (count++ < limit && mHandlerCalls < 1)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("Request executed in reasonable time", count < limit);
@@ -1451,7 +1451,7 @@ void HttpRequestTestObjectType::test<14>()
 		limit = 100;
 		while (count++ < limit && mHandlerCalls < 2)
 		{
-			req->update(1000);
+			req->update(1000000);
 			usleep(100000);
 		}
 		ensure("Second request executed in reasonable time", count < limit);
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 8243d4f2f3..0549a972e1 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -5398,7 +5398,7 @@ void CoreHttp::cleanup()
 	{
 		while (! mStopped && LLTimer::getTotalSeconds() < (mStopRequested + MAX_THREAD_WAIT_TIME))
 		{
-			mRequest->update(200);
+			mRequest->update(200000);
 			ms_sleep(50);
 		}
 		if (! mStopped)
diff --git a/indra/newview/lltexturefetch.cpp b/indra/newview/lltexturefetch.cpp
index 5c39504243..8314031f14 100755
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
@@ -2740,22 +2740,14 @@ void LLTextureFetch::commonUpdate()
 	// Run a cross-thread command, if any.
 	cmdDoWork();
 	
-	// Update Curl on same thread as mCurlGetRequest was constructed
-	LLCore::HttpStatus status = mHttpRequest->update(200);
+	// Deliver all completion notifications
+	LLCore::HttpStatus status = mHttpRequest->update(0);
 	if (! status)
 	{
 		LL_INFOS_ONCE("Texture") << "Problem during HTTP servicing.  Reason:  "
 								 << status.toString()
 								 << LL_ENDL;
 	}
-		
-#if 0
-	// *FIXME:  maybe implement this another way...
-	if (processed > 0)
-	{
-		lldebugs << "processed: " << processed << " messages." << llendl;
-	}
-#endif
 }
 
 
@@ -2840,7 +2832,8 @@ void LLTextureFetch::endThread()
 void LLTextureFetch::threadedUpdate()
 {
 	llassert_always(mHttpRequest);
-	
+
+#if 0
 	// Limit update frequency
 	const F32 PROCESS_TIME = 0.05f; 
 	static LLFrameTimer process_timer;
@@ -2849,9 +2842,10 @@ void LLTextureFetch::threadedUpdate()
 		return;
 	}
 	process_timer.reset();
+#endif
 	
 	commonUpdate();
-
+	
 #if 0
 	const F32 INFO_TIME = 1.0f; 
 	static LLFrameTimer info_timer;
@@ -2865,7 +2859,6 @@ void LLTextureFetch::threadedUpdate()
 		}
 	}
 #endif
-	
 }
 
 //////////////////////////////////////////////////////////////////////////////
-- 
cgit v1.3


From 3f032e33f2b2f929b229cf4d358b9c9d297856b8 Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Thu, 19 Jul 2012 13:41:18 -0400
Subject: SH-3280  Better init/shutdown functionality for llcorehttp by
 llappviewer Isolate llcorehttp initialization into a utility class
 (LLAppCoreHttp) that provides glue between app and library (sets up policies,
 handles notifications).  Introduce 'TextureFetchConcurrency' debug setting to
 provide some field control when absolutely necessary.

---
 indra/newview/CMakeLists.txt            |   2 +
 indra/newview/app_settings/settings.xml |  11 ++
 indra/newview/llappcorehttp.cpp         | 186 +++++++++++++++++++++++++++++++
 indra/newview/llappcorehttp.h           |  86 +++++++++++++++
 indra/newview/llappviewer.cpp           | 189 +-------------------------------
 indra/newview/llappviewer.h             |   7 ++
 indra/newview/lltexturefetch.cpp        |   9 +-
 indra/newview/lltexturefetch.h          |  12 +-
 8 files changed, 310 insertions(+), 192 deletions(-)
 create mode 100644 indra/newview/llappcorehttp.cpp
 create mode 100644 indra/newview/llappcorehttp.h

(limited to 'indra/newview/llappviewer.cpp')

diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt
index ab81cadc96..94286f0ff4 100644
--- a/indra/newview/CMakeLists.txt
+++ b/indra/newview/CMakeLists.txt
@@ -91,6 +91,7 @@ set(viewer_SOURCE_FILES
     llagentwearables.cpp
     llagentwearablesfetch.cpp
     llanimstatelabels.cpp
+    llappcorehttp.cpp
     llappearancemgr.cpp
     llappviewer.cpp
     llappviewerlistener.cpp
@@ -648,6 +649,7 @@ set(viewer_HEADER_FILES
     llagentwearables.h
     llagentwearablesfetch.h
     llanimstatelabels.h
+    llappcorehttp.h
     llappearance.h
     llappearancemgr.h
     llappviewer.h
diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml
index c9b4de0140..fc32e65410 100644
--- a/indra/newview/app_settings/settings.xml
+++ b/indra/newview/app_settings/settings.xml
@@ -10743,6 +10743,17 @@
       <key>Value</key>
       <integer>0</integer>
     </map>
+    <key>TextureFetchConcurrency</key>
+    <map>
+      <key>Comment</key>
+      <string>Maximum number of HTTP connections used for texture fetches</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>U32</string>
+      <key>Value</key>
+      <integer>0</integer>
+    </map>
     <key>TextureFetchDebuggerEnabled</key>
     <map>
       <key>Comment</key>
diff --git a/indra/newview/llappcorehttp.cpp b/indra/newview/llappcorehttp.cpp
new file mode 100644
index 0000000000..e89c8d5ac2
--- /dev/null
+++ b/indra/newview/llappcorehttp.cpp
@@ -0,0 +1,186 @@
+/**
+ * @file llappcorehttp.cpp
+ * @brief 
+ *
+ * $LicenseInfo:firstyear=2012&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2012, 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$
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "llappcorehttp.h"
+
+#include "llviewercontrol.h"
+
+
+const F64 LLAppCoreHttp::MAX_THREAD_WAIT_TIME(10.0);
+
+LLAppCoreHttp::LLAppCoreHttp()
+	: mRequest(NULL),
+	  mStopHandle(LLCORE_HTTP_HANDLE_INVALID),
+	  mStopRequested(0.0),
+	  mStopped(false),
+	  mPolicyDefault(-1)
+{}
+
+
+LLAppCoreHttp::~LLAppCoreHttp()
+{
+	delete mRequest;
+	mRequest = NULL;
+}
+
+
+void LLAppCoreHttp::init()
+{
+	LLCore::HttpStatus status = LLCore::HttpRequest::createService();
+	if (! status)
+	{
+		LL_ERRS("Init") << "Failed to initialize HTTP services.  Reason:  "
+						<< status.toString()
+						<< LL_ENDL;
+	}
+
+	// Point to our certs or SSH/https: will fail on connect
+	status = LLCore::HttpRequest::setPolicyGlobalOption(LLCore::HttpRequest::GP_CA_FILE,
+														gDirUtilp->getCAFile());
+	if (! status)
+	{
+		LL_ERRS("Init") << "Failed to set CA File for HTTP services.  Reason:  "
+						<< status.toString()
+						<< LL_ENDL;
+	}
+
+	// Establish HTTP Proxy.  "LLProxy" is a special string which directs
+	// the code to use LLProxy::applyProxySettings() to establish any
+	// HTTP or SOCKS proxy for http operations.
+	status = LLCore::HttpRequest::setPolicyGlobalOption(LLCore::HttpRequest::GP_LLPROXY, 1);
+	if (! status)
+	{
+		LL_ERRS("Init") << "Failed to set HTTP proxy for HTTP services.  Reason:  "
+						<< status.toString()
+						<< LL_ENDL;
+	}
+
+	// Tracing levels for library & libcurl (note that 2 & 3 are beyond spammy):
+	// 0 - None
+	// 1 - Basic start, stop simple transitions
+	// 2 - libcurl CURLOPT_VERBOSE mode with brief lines
+	// 3 - with partial data content
+	status = LLCore::HttpRequest::setPolicyGlobalOption(LLCore::HttpRequest::GP_TRACE, 0);
+
+	// Setup default policy and constrain if directed to
+	mPolicyDefault = LLCore::HttpRequest::DEFAULT_POLICY_ID;
+	static const std::string texture_concur("TextureFetchConcurrency");
+	if (gSavedSettings.controlExists(texture_concur))
+	{
+		U32 concur(llmin(gSavedSettings.getU32(texture_concur), U32(12)));
+
+		if (concur > 0)
+		{
+			LLCore::HttpStatus status;
+			status = LLCore::HttpRequest::setPolicyClassOption(mPolicyDefault,
+															   LLCore::HttpRequest::CP_CONNECTION_LIMIT,
+															   concur);
+			if (! status)
+			{
+				LL_WARNS("Init") << "Unable to set texture fetch concurrency.  Reason:  "
+								 << status.toString()
+								 << LL_ENDL;
+			}
+			else
+			{
+				LL_INFOS("Init") << "Application settings overriding default texture fetch concurrency.  New value:  "
+								 << concur
+								 << LL_ENDL;
+			}
+		}
+	}
+	
+	// Kick the thread
+	status = LLCore::HttpRequest::startThread();
+	if (! status)
+	{
+		LL_ERRS("Init") << "Failed to start HTTP servicing thread.  Reason:  "
+						<< status.toString()
+						<< LL_ENDL;
+	}
+
+	mRequest = new LLCore::HttpRequest;
+}
+
+
+void LLAppCoreHttp::requestStop()
+{
+	llassert_always(mRequest);
+
+	mStopHandle = mRequest->requestStopThread(this);
+	if (LLCORE_HTTP_HANDLE_INVALID != mStopHandle)
+	{
+		mStopRequested = LLTimer::getTotalSeconds();
+	}
+}
+
+
+void LLAppCoreHttp::cleanup()
+{
+	if (LLCORE_HTTP_HANDLE_INVALID == mStopHandle)
+	{
+		// Should have been started already...
+		requestStop();
+	}
+	
+	if (LLCORE_HTTP_HANDLE_INVALID == mStopHandle)
+	{
+		LL_WARNS("Cleanup") << "Attempting to cleanup HTTP services without thread shutdown"
+							<< LL_ENDL;
+	}
+	else
+	{
+		while (! mStopped && LLTimer::getTotalSeconds() < (mStopRequested + MAX_THREAD_WAIT_TIME))
+		{
+			mRequest->update(200000);
+			ms_sleep(50);
+		}
+		if (! mStopped)
+		{
+			LL_WARNS("Cleanup") << "Attempting to cleanup HTTP services with thread shutdown incomplete"
+								<< LL_ENDL;
+		}
+	}
+
+	delete mRequest;
+	mRequest = NULL;
+
+	LLCore::HttpStatus status = LLCore::HttpRequest::destroyService();
+	if (! status)
+	{
+		LL_WARNS("Cleanup") << "Failed to shutdown HTTP services, continuing.  Reason:  "
+							<< status.toString()
+							<< LL_ENDL;
+	}
+}
+
+
+void LLAppCoreHttp::onCompleted(LLCore::HttpHandle, LLCore::HttpResponse *)
+{
+	mStopped = true;
+}
diff --git a/indra/newview/llappcorehttp.h b/indra/newview/llappcorehttp.h
new file mode 100644
index 0000000000..241d73ad52
--- /dev/null
+++ b/indra/newview/llappcorehttp.h
@@ -0,0 +1,86 @@
+/**
+ * @file llappcorehttp.h
+ * @brief Singleton initialization/shutdown class for llcorehttp library
+ *
+ * $LicenseInfo:firstyear=2012&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2012, 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$
+ */
+
+#ifndef	_LL_APP_COREHTTP_H_
+#define	_LL_APP_COREHTTP_H_
+
+
+#include "httprequest.h"
+#include "httphandler.h"
+#include "httpresponse.h"
+
+
+// This class manages the lifecyle of the core http library.
+// Slightly different style than traditional code but reflects
+// the use of handler classes and light-weight interface
+// object instances of the new libraries.  To be used
+// as a singleton and static construction is fine.
+class LLAppCoreHttp : public LLCore::HttpHandler
+{
+public:
+	LLAppCoreHttp();
+	~LLAppCoreHttp();
+	
+	// Initialize the LLCore::HTTP library creating service classes
+	// and starting the servicing thread.  Caller is expected to do
+	// other initializations (SSL mutex, thread hash function) appropriate
+	// for the application.
+	void init();
+
+	// Request that the servicing thread stop servicing requests,
+	// release resource references and stop.  Request is asynchronous
+	// and @see cleanup() will perform a limited wait loop for this
+	// request to stop the thread.
+	void requestStop();
+	
+	// Terminate LLCore::HTTP library services.  Caller is expected
+	// to have made a best-effort to shutdown the servicing thread
+	// by issuing a requestThreadStop() and waiting for completion
+	// notification that the stop has completed.
+	void cleanup();
+
+	// Notification when the stop request is complete.
+	virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);
+
+	// Retrieve the policy class for default operations.
+	int getPolicyDefault() const
+		{
+			return mPolicyDefault;
+		}
+	
+private:
+	static const F64			MAX_THREAD_WAIT_TIME;
+	
+private:
+	LLCore::HttpRequest *		mRequest;
+	LLCore::HttpHandle			mStopHandle;
+	F64							mStopRequested;
+	bool						mStopped;
+	int							mPolicyDefault;
+};
+
+
+#endif	// _LL_APP_COREHTTP_H_
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 0549a972e1..f8ee1a477f 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -215,10 +215,6 @@
 #include "llmachineid.h"
 #include "llmainlooprepeater.h"
 
-// LLCore::HTTP
-#include "httpcommon.h"
-#include "httprequest.h"
-#include "httphandler.h"
 
 // *FIX: These extern globals should be cleaned up.
 // The globals either represent state/config/resource-storage of either 
@@ -334,53 +330,6 @@ static std::string gLaunchFileOnQuit;
 // Used on Win32 for other apps to identify our window (eg, win_setup)
 const char* const VIEWER_WINDOW_CLASSNAME = "Second Life";
 
-namespace
-{
-
-// This class manages the lifecyle of the core http library.
-// Slightly different style than traditional code but reflects
-// the use of handler classes and light-weight interface
-// object instances of the new libraries.  To be used
-// as a singleton and static construction is fine.
-class CoreHttp : public LLCore::HttpHandler
-{
-public:
-	CoreHttp();
-	~CoreHttp();
-	
-	// Initialize the LLCore::HTTP library creating service classes
-	// and starting the servicing thread.  Caller is expected to do
-	// other initializations (SSL mutex, thread hash function) appropriate
-	// for the application.
-	void init();
-
-	// Request that the servicing thread stop servicing requests,
-	// release resource references and stop.
-	void requestStop();
-	
-	// Terminate LLCore::HTTP library services.  Caller is expected
-	// to have made a best-effort to shutdown the servicing thread
-	// by issuing a requestThreadStop() and waiting for completion
-	// notification that the stop has completed.
-	void cleanup();
-
-	// Notification when the stop request is complete.
-	virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);
-
-private:
-	static const F64			MAX_THREAD_WAIT_TIME;
-	
-private:
-	LLCore::HttpRequest *		mRequest;
-	LLCore::HttpHandle			mStopHandle;
-	F64							mStopRequested;
-	bool						mStopped;
-};
-
-CoreHttp coreHttpLib;
-	
-}  // end anonymous namespace
-
 //-- LLDeferredTaskList ------------------------------------------------------
 
 /**
@@ -775,8 +724,9 @@ bool LLAppViewer::init()
 	LLViewerStatsRecorder::initClass();
 #endif
 
-	// Initialize the non-LLCurl libcurl library
-	coreHttpLib.init();
+	// Initialize the non-LLCurl libcurl library.  Should be called
+	// before consumers (LLTextureFetch).
+	mAppCoreHttp.init();
 	
     // *NOTE:Mani - LLCurl::initClass is not thread safe. 
     // Called before threads are created.
@@ -1915,7 +1865,7 @@ bool LLAppViewer::cleanup()
 
 	// Delete workers first
 	// shotdown all worker threads before deleting them in case of co-dependencies
-	coreHttpLib.requestStop();
+	mAppCoreHttp.requestStop();
 	sTextureFetch->shutdown();
 	sTextureCache->shutdown();	
 	sImageDecodeThread->shutdown();
@@ -2000,7 +1950,7 @@ bool LLAppViewer::cleanup()
 	LLCurl::cleanupClass();
 
 	// Non-LLCurl libcurl library
-	coreHttpLib.cleanup();
+	mAppCoreHttp.cleanup();
 
 	// If we're exiting to launch an URL, do that here so the screen
 	// is at the right resolution before we launch IE.
@@ -5298,132 +5248,3 @@ void LLAppViewer::metricsSend(bool enable_reporting)
 	gViewerAssetStatsMain->reset();
 }
 
-namespace
-{
-
-const F64 CoreHttp::MAX_THREAD_WAIT_TIME(10.0);
-
-CoreHttp::CoreHttp()
-	: mRequest(NULL),
-	  mStopHandle(LLCORE_HTTP_HANDLE_INVALID),
-	  mStopRequested(0.0),
-	  mStopped(false)
-{}
-
-
-CoreHttp::~CoreHttp()
-{
-	delete mRequest;
-	mRequest = NULL;
-}
-
-
-void CoreHttp::init()
-{
-	LLCore::HttpStatus status = LLCore::HttpRequest::createService();
-	if (! status)
-	{
-		LL_ERRS("Init") << "Failed to initialize HTTP services.  Reason:  "
-						<< status.toString()
-						<< LL_ENDL;
-	}
-
-	// Point to our certs or SSH/https: will fail on connect
-	status = LLCore::HttpRequest::setPolicyGlobalOption(LLCore::HttpRequest::GP_CA_FILE,
-														gDirUtilp->getCAFile());
-	if (! status)
-	{
-		LL_ERRS("Init") << "Failed to set CA File for HTTP services.  Reason:  "
-						<< status.toString()
-						<< LL_ENDL;
-	}
-
-	// Establish HTTP Proxy.  "LLProxy" is a special string which directs
-	// the code to use LLProxy::applyProxySettings() to establish any
-	// HTTP or SOCKS proxy for http operations.
-	status = LLCore::HttpRequest::setPolicyGlobalOption(LLCore::HttpRequest::GP_LLPROXY, 1);
-	if (! status)
-	{
-		LL_ERRS("Init") << "Failed to set HTTP proxy for HTTP services.  Reason:  "
-						<< status.toString()
-						<< LL_ENDL;
-	}
-
-	// Tracing levels for library & libcurl (note that 2 & 3 are beyond spammy):
-	// 0 - None
-	// 1 - Basic start, stop simple transitions
-	// 2 - libcurl CURLOPT_VERBOSE mode with brief lines
-	// 3 - with partial data content
-	status = LLCore::HttpRequest::setPolicyGlobalOption(LLCore::HttpRequest::GP_TRACE, 0);
-
-	// Kick the thread
-	status = LLCore::HttpRequest::startThread();
-	if (! status)
-	{
-		LL_ERRS("Init") << "Failed to start HTTP servicing thread.  Reason:  "
-						<< status.toString()
-						<< LL_ENDL;
-	}
-
-	mRequest = new LLCore::HttpRequest;
-}
-
-
-void CoreHttp::requestStop()
-{
-	llassert_always(mRequest);
-
-	mStopHandle = mRequest->requestStopThread(this);
-	if (LLCORE_HTTP_HANDLE_INVALID != mStopHandle)
-	{
-		mStopRequested = LLTimer::getTotalSeconds();
-	}
-}
-
-
-void CoreHttp::cleanup()
-{
-	if (LLCORE_HTTP_HANDLE_INVALID == mStopHandle)
-	{
-		// Should have been started already...
-		requestStop();
-	}
-	
-	if (LLCORE_HTTP_HANDLE_INVALID == mStopHandle)
-	{
-		LL_WARNS("Cleanup") << "Attempting to cleanup HTTP services without thread shutdown"
-							<< LL_ENDL;
-	}
-	else
-	{
-		while (! mStopped && LLTimer::getTotalSeconds() < (mStopRequested + MAX_THREAD_WAIT_TIME))
-		{
-			mRequest->update(200000);
-			ms_sleep(50);
-		}
-		if (! mStopped)
-		{
-			LL_WARNS("Cleanup") << "Attempting to cleanup HTTP services with thread shutdown incomplete"
-								<< LL_ENDL;
-		}
-	}
-
-	delete mRequest;
-	mRequest = NULL;
-
-	LLCore::HttpStatus status = LLCore::HttpRequest::destroyService();
-	if (! status)
-	{
-		LL_WARNS("Cleanup") << "Failed to shutdown HTTP services, continuing.  Reason:  "
-							<< status.toString()
-							<< LL_ENDL;
-	}
-}
-
-
-void CoreHttp::onCompleted(LLCore::HttpHandle, LLCore::HttpResponse *)
-{
-	mStopped = true;
-}
-
-}  // end anonymous namespace
diff --git a/indra/newview/llappviewer.h b/indra/newview/llappviewer.h
index f7d019ccba..a694ea9fe6 100644
--- a/indra/newview/llappviewer.h
+++ b/indra/newview/llappviewer.h
@@ -31,6 +31,7 @@
 #include "llcontrol.h"
 #include "llsys.h"			// for LLOSInfo
 #include "lltimer.h"
+#include "llappcorehttp.h"
 
 class LLCommandLineParser;
 class LLFrameTimer;
@@ -173,6 +174,9 @@ public:
 	// Metrics policy helper statics.
 	static void metricsUpdateRegion(U64 region_handle);
 	static void metricsSend(bool enable_reporting);
+
+	// llcorehttp init/shutdown/config information.
+	LLAppCoreHttp & getAppCoreHttp()			{ return mAppCoreHttp; }
 	
 protected:
 	virtual bool initWindow(); // Initialize the viewer's window.
@@ -270,6 +274,9 @@ private:
 	
 	boost::scoped_ptr<LLUpdaterService> mUpdater;
 
+	// llcorehttp library init/shutdown helper
+	LLAppCoreHttp mAppCoreHttp;
+
 	//---------------------------------------------
 	//*NOTE: Mani - legacy updater stuff
 	// Still useable?
diff --git a/indra/newview/lltexturefetch.cpp b/indra/newview/lltexturefetch.cpp
index 51d57ccf68..b5586d1250 100755
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
@@ -868,7 +868,7 @@ LLTextureFetchWorker::LLTextureFetchWorker(LLTextureFetch* fetcher,
 	  mMetricsStartTime(0),
 	  mHttpHandle(LLCORE_HTTP_HANDLE_INVALID),
 	  mHttpBufferArray(NULL),
-	  mHttpPolicyClass(LLCore::HttpRequest::DEFAULT_POLICY_ID),
+	  mHttpPolicyClass(mFetcher->mHttpPolicyClass),
 	  mHttpActive(false),
 	  mHttpReplySize(0U),
 	  mHttpReplyOffset(0U),
@@ -2302,6 +2302,7 @@ LLTextureFetch::LLTextureFetch(LLTextureCache* cache, LLImageDecodeThread* image
 	  mHttpOptions(NULL),
 	  mHttpHeaders(NULL),
 	  mHttpMetricsHeaders(NULL),
+	  mHttpPolicyClass(LLCore::HttpRequest::DEFAULT_POLICY_ID),
 	  mHttpSemaphore(HTTP_REQUESTS_IN_QUEUE_HIGH_WATER),
 	  mTotalCacheReadCount(0U),
 	  mTotalCacheWriteCount(0U),
@@ -2324,6 +2325,7 @@ LLTextureFetch::LLTextureFetch(LLTextureCache* cache, LLImageDecodeThread* image
 	mHttpHeaders->mHeaders.push_back("Accept: image/x-j2c");
 	mHttpMetricsHeaders = new LLCore::HttpHeaders;
 	mHttpMetricsHeaders->mHeaders.push_back("Content-Type: application/llsd+xml");
+	mHttpPolicyClass = LLAppViewer::instance()->getAppCoreHttp().getPolicyDefault();
 }
 
 LLTextureFetch::~LLTextureFetch()
@@ -3631,7 +3633,6 @@ bool
 TFReqSendMetrics::doWork(LLTextureFetch * fetcher)
 {
 	static const U32 report_priority(1);
-	static const int report_policy_class(LLCore::HttpRequest::DEFAULT_POLICY_ID);
 	static LLCore::HttpHandler * const handler(fetcher->isQAMode() || true ? &stats_handler : NULL);
 	
 	if (! gViewerAssetStatsThread1)
@@ -3671,7 +3672,7 @@ TFReqSendMetrics::doWork(LLTextureFetch * fetcher)
 		LLCore::BufferArrayStream bas(ba);
 		LLSDSerialize::toXML(merged_llsd, bas);
 		
-		fetcher->getHttpRequest().requestPost(report_policy_class,
+		fetcher->getHttpRequest().requestPost(fetcher->getPolicyClass(),
 											  report_priority,
 											  mCapsURL,
 											  ba,
@@ -3797,7 +3798,7 @@ LLTextureFetchDebugger::LLTextureFetchDebugger(LLTextureFetch* fetcher, LLTextur
 	mTextureCache(cache),
 	mImageDecodeThread(imagedecodethread),
 	mHttpHeaders(NULL),
-	mHttpPolicyClass(LLCore::HttpRequest::DEFAULT_POLICY_ID)
+	mHttpPolicyClass(fetcher->getPolicyClass())
 {
 	init();
 }
diff --git a/indra/newview/lltexturefetch.h b/indra/newview/lltexturefetch.h
index 54ffeda8df..115e471bc9 100644
--- a/indra/newview/lltexturefetch.h
+++ b/indra/newview/lltexturefetch.h
@@ -164,6 +164,9 @@ public:
 	// Threads:  T*
 	LLCore::HttpRequest & getHttpRequest()	{ return *mHttpRequest; }
 
+	// Threads:  T*
+	LLCore::HttpRequest::policy_t getPolicyClass() const { return mHttpPolicyClass; }
+	
 	// Return a pointer to the shared metrics headers definition.
 	// Does not increment the reference count, caller is required
 	// to do that to hold a reference for any length of time.
@@ -339,10 +342,11 @@ private:
 	// Interfaces and objects into the core http library used
 	// to make our HTTP requests.  These replace the various
 	// LLCurl interfaces used in the past.
-	LLCore::HttpRequest *		mHttpRequest;							// Ttf
-	LLCore::HttpOptions *		mHttpOptions;							// Ttf
-	LLCore::HttpHeaders *		mHttpHeaders;							// Ttf
-	LLCore::HttpHeaders *		mHttpMetricsHeaders;					// Ttf
+	LLCore::HttpRequest *				mHttpRequest;					// Ttf
+	LLCore::HttpOptions *				mHttpOptions;					// Ttf
+	LLCore::HttpHeaders *				mHttpHeaders;					// Ttf
+	LLCore::HttpHeaders *				mHttpMetricsHeaders;			// Ttf
+	LLCore::HttpRequest::policy_t		mHttpPolicyClass;				// T*
 
 	// We use a resource semaphore to keep HTTP requests in
 	// WAIT_HTTP_RESOURCE2 if there aren't sufficient slots in the
-- 
cgit v1.3


From 3653727e7f84f10caefb6ea7dc33859455ebfa0b Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 10 Oct 2012 14:57:43 -0400
Subject: Introduce new LLDir::findSkinnedFilenames() method. Use as needed. In
 a number of different places, for different reasons, the viewer wants to load
 a UI-related file that might be overridden by a non-default skin; and within
 that skin, might further be overridden by a non-default language. Apparently,
 for each of those use cases, every individual developer approached it as an
 entirely new problem, solving it idiosyncratically for that one case. Not
 only is this a maintenance problem, but it rubs one's nose in the fact that
 most such solutions consider only a subset of the relevant skin directories.
 Richard and I evolved an API intended to address all such cases: a central
 LLDir method returning a list of relevant pathnames, from most general to
 most localized, filtered to present only existing files; plus a couple of
 convenience methods to specifically obtain the most general and most
 localized available file. There were several load-skinned-file methods
 (LLFloater::buildFromFile(), LLPanel::buildFromFile() and
 LLUICtrlFactory::createFromFile() -- apparently cloned-and-modified from each
 other) that contained funky bolted-on logic to output the loaded data to an
 optional passed LLXMLNodePtr param. The trouble is that passing that param
 forced each of these methods to subvert its normal search: specifically for
 that case, it needed to find the baseline XML file instead of the localized
 one. Richard agreed that for the intended usage (reformatting XML files) we
 should use XML schema instead, and that the hacky functionality should be
 removed. Remove it. Also remove LLUICtrlFactory::getLocalizedXMLNode(), only
 used for those three special cases. Some callers explicitly passed the
 optional LLXMLNodePtr param as NULL. Remove that. Remove
 LLFloaterUIPreview::displayFloater(save) param, which relied on the optional
 output LLXMLNodePtr param. Make onClickSaveFloater() and onClickSaveAll()
 emit popupAndPrintWarning() about discontinued functionality. Recast
 LLFloater::buildFromFile(), LLPanel::buildFromFile(),
 LLUICtrlFactory::createFromFile(), LLNotifications::loadTemplates(),
 LLUI::locateSkin(), LLFontRegistry::parseFontInfo(),
 LLUIColorTable::loadFromSettings(), LLUICtrlFactory::loadWidgetTemplate(),
 LLUICtrlFactory::getLayeredXMLNode(), LLUIImageList::initFromFile(),
 LLAppViewer::launchUpdater() and LLMediaCtrl::navigateToLocalPage() to use
 findSkinnedFilenames(). (Is LLAppViewer::launchUpdater() ever called any
 more? Apparently so -- though the linux-updater.bin logic to process the
 relevant command-line switch has been disabled. Shrug.) (Is
 LLMediaCtrl::navigateToLocalPage() ever used?? If so, why?) Remove
 LLUI::setupPaths(), getXUIPaths(), getSkinPath() and getLocalizedSkinPath().
 Remove the skins/paths.xml file read by setupPaths(). The only configuration
 it contained was the pair of partial paths "xui/en" and "xui/[LANGUAGE]" --
 hardly likely to change. getSkinPath() specifically returned the first of
 these, while getLocalizedSkinPath() specifically returned the second. This
 knowledge is now embedded in findSkinnedFilenames(). Also remove paths.xml
 from viewer_manifest.py. Remove injected xui_paths from LLFontGL::initClass()
 and LLFontRegistry::LLFontRegistry(). These are no longer needed since
 LLFontRegistry can now directly consult LLDir for its path search. Stop
 passing LLUI::getXUIPaths() to LLFontGL::initClass() in LLViewerWindow's
 constructor and initFonts() method. Add LLDir::append() and add() methods for
 the simple task of combining two path components separated by
 getDirDelimiter() -- but only if they're both non-empty. Amazing how often
 that logic is replicated. Replace some existing concatenations with add() or
 append(). New LLDir::findSkinnedFilenames() method must know current
 language. Allow injecting current language by adding an
 LLDir::setSkinFolder(language) param, and pass it where LLAppViewer::init()
 and initConfiguration() currently call setSkinFolder(). Also add
 LLDir::getSkinFolder() and getLanguage() methods. Change LLFLoaterUIPreview's
 LLLocalizationResetForcer helper to "forcibly reset language" using
 LLDir::setSkinFolder() instead of LLUI::setupPaths(). Update LLDir stubs in
 lldir_stub.cpp and llupdaterservice_test.cpp. Add
 LLDir::getUserDefaultSkinDir() to obtain often-overlooked possible skin
 directory -- like getUserSkinDir() but with "default" in place of the current
 skin name as the last path component. (However, we hope
 findSkinnedFilenames() obviates most explicit use of such individual skin
 directory pathnames.) Add LLDir unit tests for new findSkinnedFilenames() and
 add() methods -- the latter exercises append() as well. Tweak
 indra/integration_tests/llui_libtest/llui_libtest.cpp for all the above.
 Notably, comment out its export_test_floaters() function, since the essential
 LLFloater::buildFromFile(optional LLXMLNodePtr) functionality has been
 removed. This may mean that llui_libtest.cpp has little remaining value, not
 sure.

---
 .../llimage_libtest/llimage_libtest.cpp            |   2 +-
 .../llui_libtest/llui_libtest.cpp                  |  29 +-
 indra/linux_updater/linux_updater.cpp              |   2 +-
 indra/llrender/llfontgl.cpp                        |   4 +-
 indra/llrender/llfontgl.h                          |   2 +-
 indra/llrender/llfontregistry.cpp                  |  30 +-
 indra/llrender/llfontregistry.h                    |   4 +-
 indra/llui/llfloater.cpp                           |  18 +-
 indra/llui/llfloater.h                             |   2 +-
 indra/llui/llfloaterreg.cpp                        |   2 +-
 indra/llui/llnotifications.cpp                     |  25 +-
 indra/llui/llpanel.cpp                             |  18 +-
 indra/llui/llpanel.h                               |   2 +-
 indra/llui/llui.cpp                                |  87 +---
 indra/llui/llui.h                                  |   5 -
 indra/llui/lluicolortable.cpp                      |  17 +-
 indra/llui/lluictrlfactory.cpp                     |  46 +--
 indra/llui/lluictrlfactory.h                       |  17 +-
 indra/llvfs/lldir.cpp                              | 458 ++++++++++++++++-----
 indra/llvfs/lldir.h                                |  91 +++-
 indra/llvfs/tests/lldir_test.cpp                   | 339 ++++++++++++++-
 indra/newview/llappviewer.cpp                      |  65 +--
 indra/newview/lldaycyclemanager.cpp                |   2 +-
 indra/newview/llfloateruipreview.cpp               | 122 ++----
 indra/newview/llhints.cpp                          |   4 +-
 indra/newview/llmediactrl.cpp                      |  30 +-
 indra/newview/llpreviewscript.cpp                  |   2 +-
 indra/newview/llsyswellwindow.cpp                  |   4 +-
 indra/newview/lltoast.cpp                          |   2 +-
 indra/newview/llviewermedia.cpp                    |  15 +-
 indra/newview/llviewertexturelist.cpp              |  55 ++-
 indra/newview/llviewerwindow.cpp                   |   6 +-
 indra/newview/llwaterparammanager.cpp              |   2 +-
 indra/newview/llwlparammanager.cpp                 |   2 +-
 indra/newview/skins/paths.xml                      |  10 -
 indra/newview/tests/lldir_stub.cpp                 |   2 +-
 indra/newview/viewer_manifest.py                   |   1 -
 .../updater/tests/llupdaterservice_test.cpp        |   4 +-
 38 files changed, 978 insertions(+), 550 deletions(-)
 delete mode 100644 indra/newview/skins/paths.xml

(limited to 'indra/newview/llappviewer.cpp')

diff --git a/indra/integration_tests/llimage_libtest/llimage_libtest.cpp b/indra/integration_tests/llimage_libtest/llimage_libtest.cpp
index 36c5b67826..034c816742 100644
--- a/indra/integration_tests/llimage_libtest/llimage_libtest.cpp
+++ b/indra/integration_tests/llimage_libtest/llimage_libtest.cpp
@@ -240,7 +240,7 @@ void store_input_file(std::list<std::string> &input_filenames, const std::string
 		LLDirIterator iter(dir, name);
 		while (iter.next(next_name))
 		{
-			std::string file_name = dir + gDirUtilp->getDirDelimiter() + next_name;
+			std::string file_name = gDirUtilp->add(dir, next_name);
 			input_filenames.push_back(file_name);
 		}
 	}
diff --git a/indra/integration_tests/llui_libtest/llui_libtest.cpp b/indra/integration_tests/llui_libtest/llui_libtest.cpp
index 217e26c3ca..38aa1bbeb2 100644
--- a/indra/integration_tests/llui_libtest/llui_libtest.cpp
+++ b/indra/integration_tests/llui_libtest/llui_libtest.cpp
@@ -107,12 +107,6 @@ public:
 };
 TestImageProvider gTestImageProvider;
 
-static std::string get_xui_dir()
-{
-	std::string delim = gDirUtilp->getDirDelimiter();
-	return gDirUtilp->getSkinBaseDir() + delim + "default" + delim + "xui" + delim;
-}
-
 void init_llui()
 {
 	// Font lookup needs directory support
@@ -122,13 +116,12 @@ void init_llui()
 	const char* newview_path = "../../../newview";
 #endif
 	gDirUtilp->initAppDirs("SecondLife", newview_path);
-	gDirUtilp->setSkinFolder("default");
+	gDirUtilp->setSkinFolder("default", "en");
 	
 	// colors are no longer stored in a LLControlGroup file
 	LLUIColorTable::instance().loadFromSettings();
 
-	std::string config_filename = gDirUtilp->getExpandedFilename(
-																 LL_PATH_APP_SETTINGS, "settings.xml");
+	std::string config_filename = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "settings.xml");
 	gSavedSettings.loadFromFile(config_filename);
 	
 	// See LLAppViewer::init()
@@ -143,9 +136,7 @@ void init_llui()
 	
 	const bool no_register_widgets = false;
 	LLWidgetReg::initClass( no_register_widgets );
-	
-	// Unclear if this is needed
-	LLUI::setupPaths();
+
 	// Otherwise we get translation warnings when setting up floaters
 	// (tooltips for buttons)
 	std::set<std::string> default_args;
@@ -157,7 +148,6 @@ void init_llui()
 	// otherwise it crashes.
 	LLFontGL::initClass(96.f, 1.f, 1.f,
 						gDirUtilp->getAppRODataDir(),
-						LLUI::getXUIPaths(),
 						false );	// don't create gl textures
 	
 	LLFloaterView::Params fvparams;
@@ -169,6 +159,14 @@ void init_llui()
 	gFloaterView = LLUICtrlFactory::create<LLFloaterView> (fvparams);
 }
 
+/*==========================================================================*|
+static std::string get_xui_dir()
+{
+	std::string delim = gDirUtilp->getDirDelimiter();
+	return gDirUtilp->getSkinBaseDir() + delim + "default" + delim + "xui" + delim;
+}
+
+// buildFromFile() no longer supports generate-output-LLXMLNode
 void export_test_floaters()
 {
 	// Convert all test floaters to new XML format
@@ -191,7 +189,7 @@ void export_test_floaters()
 		floater->buildFromFile(	filename,
 								//	 FALSE,	// don't open floater
 								output_node);
-		std::string out_filename = xui_dir + filename;
+		std::string out_filename = gDirUtilp->add(xui_dir, filename);
 		std::string::size_type extension_pos = out_filename.rfind(".xml");
 		out_filename.resize(extension_pos);
 		out_filename += "_new.xml";
@@ -203,6 +201,7 @@ void export_test_floaters()
 		fclose(floater_file);
 	}
 }
+|*==========================================================================*/
 
 int main(int argc, char** argv)
 {
@@ -211,7 +210,7 @@ int main(int argc, char** argv)
 
 	init_llui();
 	
-	export_test_floaters();
+//	export_test_floaters();
 	
 	return 0;
 }
diff --git a/indra/linux_updater/linux_updater.cpp b/indra/linux_updater/linux_updater.cpp
index 277f0a5367..991dfd9dce 100644
--- a/indra/linux_updater/linux_updater.cpp
+++ b/indra/linux_updater/linux_updater.cpp
@@ -251,7 +251,7 @@ std::string next_image_filename(std::string& image_path, LLDirIterator& iter)
 {
 	std::string image_filename;
 	iter.next(image_filename);
-	return image_path + "/" + image_filename;
+	return gDirUtilp->add(image_path, image_filename);
 }
 
 void on_window_closed(GtkWidget *sender, GdkEvent* event, gpointer data)
diff --git a/indra/llrender/llfontgl.cpp b/indra/llrender/llfontgl.cpp
index 4dc2fcd714..647512eb2e 100644
--- a/indra/llrender/llfontgl.cpp
+++ b/indra/llrender/llfontgl.cpp
@@ -789,7 +789,7 @@ const LLFontDescriptor& LLFontGL::getFontDesc() const
 }
 
 // static
-void LLFontGL::initClass(F32 screen_dpi, F32 x_scale, F32 y_scale, const std::string& app_dir, const std::vector<std::string>& xui_paths, bool create_gl_textures)
+void LLFontGL::initClass(F32 screen_dpi, F32 x_scale, F32 y_scale, const std::string& app_dir, bool create_gl_textures)
 {
 	sVertDPI = (F32)llfloor(screen_dpi * y_scale);
 	sHorizDPI = (F32)llfloor(screen_dpi * x_scale);
@@ -800,7 +800,7 @@ void LLFontGL::initClass(F32 screen_dpi, F32 x_scale, F32 y_scale, const std::st
 	// Font registry init
 	if (!sFontRegistry)
 	{
-		sFontRegistry = new LLFontRegistry(xui_paths, create_gl_textures);
+		sFontRegistry = new LLFontRegistry(create_gl_textures);
 		sFontRegistry->parseFontInfo("fonts.xml");
 	}
 	else
diff --git a/indra/llrender/llfontgl.h b/indra/llrender/llfontgl.h
index 5ed5d2c4eb..0988e99deb 100644
--- a/indra/llrender/llfontgl.h
+++ b/indra/llrender/llfontgl.h
@@ -150,7 +150,7 @@ public:
 	const LLFontDescriptor& getFontDesc() const;
 
 
-	static void initClass(F32 screen_dpi, F32 x_scale, F32 y_scale, const std::string& app_dir, const std::vector<std::string>& xui_paths, bool create_gl_textures = true);
+	static void initClass(F32 screen_dpi, F32 x_scale, F32 y_scale, const std::string& app_dir, bool create_gl_textures = true);
 
 	// Load sans-serif, sans-serif-small, etc.
 	// Slow, requires multiple seconds to load fonts.
diff --git a/indra/llrender/llfontregistry.cpp b/indra/llrender/llfontregistry.cpp
index 4d22eba3d9..b5bdba996f 100644
--- a/indra/llrender/llfontregistry.cpp
+++ b/indra/llrender/llfontregistry.cpp
@@ -163,14 +163,9 @@ LLFontDescriptor LLFontDescriptor::normalize() const
 	return LLFontDescriptor(new_name,new_size,new_style,getFileNames());
 }
 
-LLFontRegistry::LLFontRegistry(const string_vec_t& xui_paths,
-							   bool create_gl_textures)
+LLFontRegistry::LLFontRegistry(bool create_gl_textures)
 :	mCreateGLTextures(create_gl_textures)
 {
-	// Propagate this down from LLUICtrlFactory so LLRender doesn't
-	// need an upstream dependency on LLUI.
-	mXUIPaths = xui_paths;
-	
 	// This is potentially a slow directory traversal, so we want to
 	// cache the result.
 	mUltimateFallbackList = LLWindow::getDynamicFallbackFontList();
@@ -183,27 +178,30 @@ LLFontRegistry::~LLFontRegistry()
 
 bool LLFontRegistry::parseFontInfo(const std::string& xml_filename)
 {
-	bool success = false;  // Succeed if we find at least one XUI file
-	const string_vec_t& xml_paths = mXUIPaths;
+	bool success = false;  // Succeed if we find and read at least one XUI file
+	const string_vec_t xml_paths = gDirUtilp->findSkinnedFilenames(LLDir::XUI, xml_filename);
+	if (xml_paths.empty())
+	{
+		// We didn't even find one single XUI file
+		return false;
+	}
+
 	for (string_vec_t::const_iterator path_it = xml_paths.begin();
 		 path_it != xml_paths.end();
 		 ++path_it)
 	{
-	
 		LLXMLNodePtr root;
-		std::string full_filename = gDirUtilp->findSkinnedFilename(*path_it, xml_filename);
-		bool parsed_file = LLXMLNode::parseFile(full_filename, root, NULL);
+		bool parsed_file = LLXMLNode::parseFile(*path_it, root, NULL);
 
 		if (!parsed_file)
 			continue;
-		
+
 		if ( root.isNull() || ! root->hasName( "fonts" ) )
 		{
-			llwarns << "Bad font info file: "
-					<< full_filename << llendl;
+			llwarns << "Bad font info file: " << *path_it << llendl;
 			continue;
 		}
-		
+
 		std::string root_name;
 		root->getAttributeString("name",root_name);
 		if (root->hasName("fonts"))
@@ -215,7 +213,7 @@ bool LLFontRegistry::parseFontInfo(const std::string& xml_filename)
 	}
 	//if (success)
 	//	dump();
-	
+
 	return success;
 }
 
diff --git a/indra/llrender/llfontregistry.h b/indra/llrender/llfontregistry.h
index 8b06191c56..059248fbbd 100644
--- a/indra/llrender/llfontregistry.h
+++ b/indra/llrender/llfontregistry.h
@@ -67,8 +67,7 @@ class LLFontRegistry
 public:
 	// create_gl_textures - set to false for test apps with no OpenGL window,
 	// such as llui_libtest
-	LLFontRegistry(const string_vec_t& xui_paths,
-		bool create_gl_textures);
+	LLFontRegistry(bool create_gl_textures);
 	~LLFontRegistry();
 
 	// Load standard font info from XML file(s).
@@ -105,7 +104,6 @@ private:
 	font_size_map_t mFontSizes;
 
 	string_vec_t mUltimateFallbackList;
-	string_vec_t mXUIPaths;
 	bool mCreateGLTextures;
 };
 
diff --git a/indra/llui/llfloater.cpp b/indra/llui/llfloater.cpp
index 8ca1e685a9..33295f882d 100644
--- a/indra/llui/llfloater.cpp
+++ b/indra/llui/llfloater.cpp
@@ -3229,24 +3229,14 @@ bool LLFloater::isVisible(const LLFloater* floater)
 
 static LLFastTimer::DeclareTimer FTM_BUILD_FLOATERS("Build Floaters");
 
-bool LLFloater::buildFromFile(const std::string& filename, LLXMLNodePtr output_node)
+bool LLFloater::buildFromFile(const std::string& filename)
 {
 	LLFastTimer timer(FTM_BUILD_FLOATERS);
 	LLXMLNodePtr root;
 
-	//if exporting, only load the language being exported, 
-	//instead of layering localized version on top of english
-	if (output_node)
-	{
-		if (!LLUICtrlFactory::getLocalizedXMLNode(filename, root))
-		{
-			llwarns << "Couldn't parse floater from: " << LLUI::getLocalizedSkinPath() + gDirUtilp->getDirDelimiter() + filename << llendl;
-			return false;
-		}
-	}
-	else if (!LLUICtrlFactory::getLayeredXMLNode(filename, root))
+	if (!LLUICtrlFactory::getLayeredXMLNode(filename, root))
 	{
-		llwarns << "Couldn't parse floater from: " << LLUI::getSkinPath() + gDirUtilp->getDirDelimiter() + filename << llendl;
+		llwarns << "Couldn't find (or parse) floater from: " << filename << llendl;
 		return false;
 	}
 	
@@ -3271,7 +3261,7 @@ bool LLFloater::buildFromFile(const std::string& filename, LLXMLNodePtr output_n
 		getCommitCallbackRegistrar().pushScope();
 		getEnableCallbackRegistrar().pushScope();
 		
-		res = initFloaterXML(root, getParent(), filename, output_node);
+		res = initFloaterXML(root, getParent(), filename, NULL);
 
 		setXMLFilename(filename);
 		
diff --git a/indra/llui/llfloater.h b/indra/llui/llfloater.h
index 64d6dcea04..e64b6d04d3 100644
--- a/indra/llui/llfloater.h
+++ b/indra/llui/llfloater.h
@@ -202,7 +202,7 @@ public:
 
 	// Don't export top/left for rect, only height/width
 	static void setupParamsForExport(Params& p, LLView* parent);
-	bool buildFromFile(const std::string &filename, LLXMLNodePtr output_node = NULL);
+	bool buildFromFile(const std::string &filename);
 
 	boost::signals2::connection setMinimizeCallback( const commit_signal_t::slot_type& cb );
 	boost::signals2::connection setOpenCallback( const commit_signal_t::slot_type& cb );
diff --git a/indra/llui/llfloaterreg.cpp b/indra/llui/llfloaterreg.cpp
index 9115eb7174..306caf2b91 100644
--- a/indra/llui/llfloaterreg.cpp
+++ b/indra/llui/llfloaterreg.cpp
@@ -154,7 +154,7 @@ LLFloater* LLFloaterReg::getInstance(const std::string& name, const LLSD& key)
 					llwarns << "Failed to build floater type: '" << name << "'." << llendl;
 					return NULL;
 				}
-				bool success = res->buildFromFile(xui_file, NULL);
+				bool success = res->buildFromFile(xui_file);
 				if (!success)
 				{
 					llwarns << "Failed to build floater type: '" << name << "'." << llendl;
diff --git a/indra/llui/llnotifications.cpp b/indra/llui/llnotifications.cpp
index 629eef2c3b..4fbee8cd80 100644
--- a/indra/llui/llnotifications.cpp
+++ b/indra/llui/llnotifications.cpp
@@ -1424,25 +1424,18 @@ void addPathIfExists(const std::string& new_path, std::vector<std::string>& path
 bool LLNotifications::loadTemplates()
 {
 	llinfos << "Reading notifications template" << llendl;
-	std::vector<std::string> search_paths;
-	
-	std::string skin_relative_path = gDirUtilp->getDirDelimiter() + LLUI::getSkinPath() + gDirUtilp->getDirDelimiter() + "notifications.xml";
-	std::string localized_skin_relative_path = gDirUtilp->getDirDelimiter() + LLUI::getLocalizedSkinPath() + gDirUtilp->getDirDelimiter() + "notifications.xml";
-
-	addPathIfExists(gDirUtilp->getDefaultSkinDir() + skin_relative_path, search_paths);
-	addPathIfExists(gDirUtilp->getDefaultSkinDir() + localized_skin_relative_path, search_paths);
-	addPathIfExists(gDirUtilp->getSkinDir() + skin_relative_path, search_paths);
-	addPathIfExists(gDirUtilp->getSkinDir() + localized_skin_relative_path, search_paths);
-	addPathIfExists(gDirUtilp->getUserSkinDir() + skin_relative_path, search_paths);
-	addPathIfExists(gDirUtilp->getUserSkinDir() + localized_skin_relative_path, search_paths);
+	// Passing findSkinnedFilenames(merge=true) makes it output all relevant
+	// pathnames instead of just the ones from the most specific skin.
+	std::vector<std::string> search_paths =
+		gDirUtilp->findSkinnedFilenames(LLDir::XUI, "notifications.xml", true);
 
 	std::string base_filename = search_paths.front();
 	LLXMLNodePtr root;
 	BOOL success  = LLXMLNode::getLayeredXMLNode(root, search_paths);
-	
+
 	if (!success || root.isNull() || !root->hasName( "notifications" ))
 	{
-		llerrs << "Problem reading UI Notifications file: " << base_filename << llendl;
+		llerrs << "Problem reading XML from UI Notifications file: " << base_filename << llendl;
 		return false;
 	}
 
@@ -1452,7 +1445,7 @@ bool LLNotifications::loadTemplates()
 
 	if(!params.validateBlock())
 	{
-		llerrs << "Problem reading UI Notifications file: " << base_filename << llendl;
+		llerrs << "Problem reading XUI from UI Notifications file: " << base_filename << llendl;
 		return false;
 	}
 
@@ -1508,7 +1501,9 @@ bool LLNotifications::loadTemplates()
 bool LLNotifications::loadVisibilityRules()
 {
 	const std::string xml_filename = "notification_visibility.xml";
-	std::string full_filename = gDirUtilp->findSkinnedFilename(LLUI::getXUIPaths().front(), xml_filename);
+	// Note that here we're looking for the "en" version, the default
+	// language, rather than the most localized version of this file.
+	std::string full_filename = gDirUtilp->findSkinnedFilenameBaseLang(LLDir::XUI, xml_filename);
 
 	LLNotificationVisibilityRule::Rules params;
 	LLSimpleXUIParser parser;
diff --git a/indra/llui/llpanel.cpp b/indra/llui/llpanel.cpp
index 00318cec6b..67472ad166 100644
--- a/indra/llui/llpanel.cpp
+++ b/indra/llui/llpanel.cpp
@@ -968,25 +968,15 @@ static LLFastTimer::DeclareTimer FTM_BUILD_PANELS("Build Panels");
 //-----------------------------------------------------------------------------
 // buildPanel()
 //-----------------------------------------------------------------------------
-BOOL LLPanel::buildFromFile(const std::string& filename, LLXMLNodePtr output_node, const LLPanel::Params& default_params)
+BOOL LLPanel::buildFromFile(const std::string& filename, const LLPanel::Params& default_params)
 {
 	LLFastTimer timer(FTM_BUILD_PANELS);
 	BOOL didPost = FALSE;
 	LLXMLNodePtr root;
 
-	//if exporting, only load the language being exported, 
-	//instead of layering localized version on top of english
-	if (output_node)
-	{	
-		if (!LLUICtrlFactory::getLocalizedXMLNode(filename, root))
-		{
-			llwarns << "Couldn't parse panel from: " << LLUI::getLocalizedSkinPath() + gDirUtilp->getDirDelimiter() + filename  << llendl;
-			return didPost;
-		}
-	}
-	else if (!LLUICtrlFactory::getLayeredXMLNode(filename, root))
+	if (!LLUICtrlFactory::getLayeredXMLNode(filename, root))
 	{
-		llwarns << "Couldn't parse panel from: " << LLUI::getSkinPath() + gDirUtilp->getDirDelimiter() + filename << llendl;
+		llwarns << "Couldn't parse panel from: " << filename << llendl;
 		return didPost;
 	}
 
@@ -1010,7 +1000,7 @@ BOOL LLPanel::buildFromFile(const std::string& filename, LLXMLNodePtr output_nod
 		getCommitCallbackRegistrar().pushScope();
 		getEnableCallbackRegistrar().pushScope();
 		
-		didPost = initPanelXML(root, NULL, output_node, default_params);
+		didPost = initPanelXML(root, NULL, NULL, default_params);
 
 		getCommitCallbackRegistrar().popScope();
 		getEnableCallbackRegistrar().popScope();
diff --git a/indra/llui/llpanel.h b/indra/llui/llpanel.h
index f620201020..e63b41f97c 100644
--- a/indra/llui/llpanel.h
+++ b/indra/llui/llpanel.h
@@ -105,7 +105,7 @@ protected:
 	LLPanel(const LLPanel::Params& params = getDefaultParams());
 	
 public:
-	BOOL buildFromFile(const std::string &filename, LLXMLNodePtr output_node = NULL, const LLPanel::Params&default_params = getDefaultParams());
+	BOOL buildFromFile(const std::string &filename, const LLPanel::Params& default_params = getDefaultParams());
 
 	static LLPanel* createFactoryPanel(const std::string& name);
 
diff --git a/indra/llui/llui.cpp b/indra/llui/llui.cpp
index 87bf518aa1..507ced9172 100644
--- a/indra/llui/llui.cpp
+++ b/indra/llui/llui.cpp
@@ -1836,88 +1836,39 @@ struct Paths : public LLInitParam::Block<Paths>
 	{}
 };
 
-//static
-void LLUI::setupPaths()
-{
-	std::string filename = gDirUtilp->getExpandedFilename(LL_PATH_SKINS, "paths.xml");
-
-	LLXMLNodePtr root;
-	BOOL success  = LLXMLNode::parseFile(filename, root, NULL);
-	Paths paths;
-
-	if(success)
-	{
-		LLXUIParser parser;
-		parser.readXUI(root, paths, filename);
-	}
-	sXUIPaths.clear();
-	
-	if (success && paths.validateBlock())
-	{
-		LLStringUtil::format_map_t path_args;
-		path_args["[LANGUAGE]"] = LLUI::getLanguage();
-		
-		for (LLInitParam::ParamIterator<Directory>::const_iterator it = paths.directories.begin(), 
-				end_it = paths.directories.end();
-			it != end_it;
-			++it)
-		{
-			std::string path_val_ui;
-			for (LLInitParam::ParamIterator<SubDir>::const_iterator subdir_it = it->subdirs.begin(),
-					subdir_end_it = it->subdirs.end();
-				subdir_it != subdir_end_it;)
-			{
-				path_val_ui += subdir_it->value();
-				if (++subdir_it != subdir_end_it)
-					path_val_ui += gDirUtilp->getDirDelimiter();
-			}
-			LLStringUtil::format(path_val_ui, path_args);
-			if (std::find(sXUIPaths.begin(), sXUIPaths.end(), path_val_ui) == sXUIPaths.end())
-			{
-				sXUIPaths.push_back(path_val_ui);
-			}
-
-		}
-	}
-	else // parsing failed
-	{
-		std::string slash = gDirUtilp->getDirDelimiter();
-		std::string dir = "xui" + slash + "en";
-		llwarns << "XUI::config file unable to open: " << filename << llendl;
-		sXUIPaths.push_back(dir);
-	}
-}
-
 
 //static
 std::string LLUI::locateSkin(const std::string& filename)
 {
-	std::string slash = gDirUtilp->getDirDelimiter();
 	std::string found_file = filename;
-	if (!gDirUtilp->fileExists(found_file))
+	if (gDirUtilp->fileExists(found_file))
 	{
-		found_file = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, filename); // Should be CUSTOM_SKINS?
+		return found_file;
 	}
-	if (sSettingGroups["config"] && sSettingGroups["config"]->controlExists("Language"))
+
+	found_file = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, filename); // Should be CUSTOM_SKINS?
+	if (gDirUtilp->fileExists(found_file))
 	{
-		if (!gDirUtilp->fileExists(found_file))
-		{
-			std::string localization = getLanguage();
-			std::string local_skin = "xui" + slash + localization + slash + filename;
-			found_file = gDirUtilp->findSkinnedFilename(local_skin);
-		}
+		return found_file;
 	}
-	if (!gDirUtilp->fileExists(found_file))
+
+	found_file = gDirUtilp->findSkinnedFilename(LLDir::XUI, filename);
+	if (! found_file.empty())
 	{
-		std::string local_skin = "xui" + slash + "en" + slash + filename;
-		found_file = gDirUtilp->findSkinnedFilename(local_skin);
+		return found_file;
 	}
-	if (!gDirUtilp->fileExists(found_file))
+
+	found_file = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, filename);
+/*==========================================================================*|
+	// Hmm, if we got this far, previous implementation of this method would
+	// return this last found_file value whether or not it actually exists.
+	if (gDirUtilp->fileExists(found_file))
 	{
-		found_file = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, filename);
+		return found_file;
 	}
+|*==========================================================================*/
 	return found_file;
-}	
+}
 
 //static
 LLVector2 LLUI::getWindowSize()
diff --git a/indra/llui/llui.h b/indra/llui/llui.h
index 28e84fa444..c5a12d2b31 100644
--- a/indra/llui/llui.h
+++ b/indra/llui/llui.h
@@ -292,11 +292,6 @@ public:
 	// Return the ISO639 language name ("en", "ko", etc.) for the viewer UI.
 	// http://www.loc.gov/standards/iso639-2/php/code_list.php
 	static std::string getLanguage();
-	
-	static void setupPaths();
-	static const std::vector<std::string>& getXUIPaths() { return sXUIPaths; }
-	static std::string getSkinPath() { return sXUIPaths.front(); }
-	static std::string getLocalizedSkinPath() { return sXUIPaths.back(); }  //all files may not exist at the localized path
 
 	//helper functions (should probably move free standing rendering helper functions here)
 	static LLView* getRootView() { return sRootView; }
diff --git a/indra/llui/lluicolortable.cpp b/indra/llui/lluicolortable.cpp
index 9455d09cc0..2717445396 100644
--- a/indra/llui/lluicolortable.cpp
+++ b/indra/llui/lluicolortable.cpp
@@ -32,6 +32,7 @@
 #include "llui.h"
 #include "lluicolortable.h"
 #include "lluictrlfactory.h"
+#include <boost/foreach.hpp>
 
 LLUIColorTable::ColorParams::ColorParams()
 :	value("value"),
@@ -206,19 +207,11 @@ bool LLUIColorTable::loadFromSettings()
 {
 	bool result = false;
 
-	std::string default_filename = gDirUtilp->getExpandedFilename(LL_PATH_DEFAULT_SKIN, "colors.xml");
-	result |= loadFromFilename(default_filename, mLoadedColors);
-
-	std::string current_filename = gDirUtilp->getExpandedFilename(LL_PATH_TOP_SKIN, "colors.xml");
-	if(current_filename != default_filename)
-	{
-		result |= loadFromFilename(current_filename, mLoadedColors);
-	}
-
-	current_filename = gDirUtilp->getExpandedFilename(LL_PATH_USER_SKIN, "colors.xml");
-	if(current_filename != default_filename)
+	// pass merge=true because we want colors.xml from every skin dir
+	BOOST_FOREACH(std::string colors_path,
+				  gDirUtilp->findSkinnedFilenames(LLDir::SKINBASE, "colors.xml", true))
 	{
-		result |= loadFromFilename(current_filename, mLoadedColors);
+		result |= loadFromFilename(colors_path, mLoadedColors);
 	}
 
 	std::string user_filename = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, "colors.xml");
diff --git a/indra/llui/lluictrlfactory.cpp b/indra/llui/lluictrlfactory.cpp
index 25e7a31e90..2b317b46e3 100644
--- a/indra/llui/lluictrlfactory.cpp
+++ b/indra/llui/lluictrlfactory.cpp
@@ -90,10 +90,12 @@ LLUICtrlFactory::~LLUICtrlFactory()
 
 void LLUICtrlFactory::loadWidgetTemplate(const std::string& widget_tag, LLInitParam::BaseBlock& block)
 {
-	std::string filename = std::string("widgets") + gDirUtilp->getDirDelimiter() + widget_tag + ".xml";
+	std::string filename = gDirUtilp->add("widgets", widget_tag + ".xml");
 	LLXMLNodePtr root_node;
 
-	std::string full_filename = gDirUtilp->findSkinnedFilename(LLUI::getXUIPaths().front(), filename);
+	// Here we're looking for the "en" version, the default-language version
+	// of the file, rather than the localized version.
+	std::string full_filename = gDirUtilp->findSkinnedFilenameBaseLang(LLDir::XUI, filename);
 	if (!full_filename.empty())
 	{
 		LLUICtrlFactory::instance().pushFileName(full_filename);
@@ -152,19 +154,8 @@ static LLFastTimer::DeclareTimer FTM_XML_PARSE("XML Reading/Parsing");
 bool LLUICtrlFactory::getLayeredXMLNode(const std::string &xui_filename, LLXMLNodePtr& root)
 {
 	LLFastTimer timer(FTM_XML_PARSE);
-	
-	std::vector<std::string> paths;
-	std::string path = gDirUtilp->findSkinnedFilename(LLUI::getSkinPath(), xui_filename);
-	if (!path.empty())
-	{
-		paths.push_back(path);
-	}
-
-	std::string localize_path = gDirUtilp->findSkinnedFilename(LLUI::getLocalizedSkinPath(), xui_filename);
-	if (!localize_path.empty() && localize_path != path)
-	{
-		paths.push_back(localize_path);
-	}
+	std::vector<std::string> paths =
+		gDirUtilp->findSkinnedFilenames(LLDir::XUI, xui_filename);
 
 	if (paths.empty())
 	{
@@ -176,23 +167,6 @@ bool LLUICtrlFactory::getLayeredXMLNode(const std::string &xui_filename, LLXMLNo
 }
 
 
-//-----------------------------------------------------------------------------
-// getLocalizedXMLNode()
-//-----------------------------------------------------------------------------
-bool LLUICtrlFactory::getLocalizedXMLNode(const std::string &xui_filename, LLXMLNodePtr& root)
-{
-	LLFastTimer timer(FTM_XML_PARSE);
-	std::string full_filename = gDirUtilp->findSkinnedFilename(LLUI::getLocalizedSkinPath(), xui_filename);
-	if (!LLXMLNode::parseFile(full_filename, root, NULL))
-	{
-		return false;
-	}
-	else
-	{
-		return true;
-	}
-}
-
 //-----------------------------------------------------------------------------
 // saveToXML()
 //-----------------------------------------------------------------------------
@@ -239,8 +213,10 @@ std::string LLUICtrlFactory::getCurFileName()
 
 
 void LLUICtrlFactory::pushFileName(const std::string& name) 
-{ 
-	mFileNames.push_back(gDirUtilp->findSkinnedFilename(LLUI::getSkinPath(), name)); 
+{
+	// Here we seem to be looking for the default language file ("en") rather
+	// than the localized one, if any.
+	mFileNames.push_back(gDirUtilp->findSkinnedFilenameBaseLang(LLDir::XUI, name));
 }
 
 void LLUICtrlFactory::popFileName() 
@@ -260,7 +236,7 @@ void LLUICtrlFactory::setCtrlParent(LLView* view, LLView* parent, S32 tab_group)
 //static
 std::string LLUICtrlFactory::findSkinnedFilename(const std::string& filename)
 {
-	return gDirUtilp->findSkinnedFilename(LLUI::getSkinPath(), filename);
+	return gDirUtilp->findSkinnedFilenameBaseLang(LLDir::XUI, filename);
 }
 
 //static 
diff --git a/indra/llui/lluictrlfactory.h b/indra/llui/lluictrlfactory.h
index d612ad5005..56e5f3eb7b 100644
--- a/indra/llui/lluictrlfactory.h
+++ b/indra/llui/lluictrlfactory.h
@@ -169,7 +169,7 @@ public:
 	LLView* createFromXML(LLXMLNodePtr node, LLView* parent, const std::string& filename, const widget_registry_t&, LLXMLNodePtr output_node );
 
 	template<typename T>
-	static T* createFromFile(const std::string &filename, LLView *parent, const widget_registry_t& registry, LLXMLNodePtr output_node = NULL)
+	static T* createFromFile(const std::string &filename, LLView *parent, const widget_registry_t& registry)
 	{
 		T* widget = NULL;
 		
@@ -178,23 +178,13 @@ public:
 		{
 			LLXMLNodePtr root_node;
 
-			//if exporting, only load the language being exported, 			
-			//instead of layering localized version on top of english			
-			if (output_node)			
-			{					
-				if (!LLUICtrlFactory::getLocalizedXMLNode(filename, root_node))				
-				{							
-					llwarns << "Couldn't parse XUI file: " <<  filename  << llendl;					
-					goto fail;				
-				}
-			}
-			else if (!LLUICtrlFactory::getLayeredXMLNode(filename, root_node))
+			if (!LLUICtrlFactory::getLayeredXMLNode(filename, root_node))
 			{
 				llwarns << "Couldn't parse XUI file: " << skinned_filename << llendl;
 				goto fail;
 			}
 			
-			LLView* view = getInstance()->createFromXML(root_node, parent, filename, registry, output_node);
+			LLView* view = getInstance()->createFromXML(root_node, parent, filename, registry, NULL);
 			if (view)
 			{
 				widget = dynamic_cast<T*>(view);
@@ -223,7 +213,6 @@ fail:
 	static void createChildren(LLView* viewp, LLXMLNodePtr node, const widget_registry_t&, LLXMLNodePtr output_node = NULL);
 
 	static bool getLayeredXMLNode(const std::string &filename, LLXMLNodePtr& root);
-	static bool getLocalizedXMLNode(const std::string &xui_filename, LLXMLNodePtr& root);
 
 private:
 	//NOTE: both friend declarations are necessary to keep both gcc and msvc happy
diff --git a/indra/llvfs/lldir.cpp b/indra/llvfs/lldir.cpp
index 32d081d552..a7d12476a4 100644
--- a/indra/llvfs/lldir.cpp
+++ b/indra/llvfs/lldir.cpp
@@ -41,6 +41,12 @@
 #include "lluuid.h"
 
 #include "lldiriterator.h"
+#include "stringize.h"
+#include <boost/foreach.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <algorithm>
+#include <iomanip>
 
 #if LL_WINDOWS
 #include "lldir_win32.h"
@@ -58,6 +64,14 @@ LLDir_Linux gDirUtil;
 
 LLDir *gDirUtilp = (LLDir *)&gDirUtil;
 
+/// Values for findSkinnedFilenames(subdir) parameter
+const char
+	*LLDir::XUI      = "xui",
+	*LLDir::TEXTURES = "textures",
+	*LLDir::SKINBASE = "";
+
+static const char* const empty = "";
+
 LLDir::LLDir()
 :	mAppName(""),
 	mExecutablePathAndName(""),
@@ -70,7 +84,8 @@ LLDir::LLDir()
 	mOSCacheDir(""),
 	mCAFile(""),
 	mTempDir(""),
-	mDirDelimiter("/") // fallback to forward slash if not overridden
+	mDirDelimiter("/"), // fallback to forward slash if not overridden
+	mLanguage("en")
 {
 }
 
@@ -96,9 +111,7 @@ S32 LLDir::deleteFilesInDir(const std::string &dirname, const std::string &mask)
 	LLDirIterator iter(dirname, mask);
 	while (iter.next(filename))
 	{
-		fullpath = dirname;
-		fullpath += getDirDelimiter();
-		fullpath += filename;
+		fullpath = add(dirname, filename);
 
 		if(LLFile::isdir(fullpath))
 		{
@@ -270,12 +283,12 @@ std::string LLDir::buildSLOSCacheDir() const
 		}
 		else
 		{
-			res = getOSUserAppDir() + mDirDelimiter + "cache";
+			res = add(getOSUserAppDir(), "cache");
 		}
 	}
 	else
 	{
-		res = getOSCacheDir() + mDirDelimiter + "SecondLife";
+		res = add(getOSCacheDir(), "SecondLife");
 	}
 	return res;
 }
@@ -298,19 +311,24 @@ const std::string &LLDir::getDirDelimiter() const
 	return mDirDelimiter;
 }
 
+const std::string& LLDir::getDefaultSkinDir() const
+{
+	return mDefaultSkinDir;
+}
+
 const std::string &LLDir::getSkinDir() const
 {
 	return mSkinDir;
 }
 
-const std::string &LLDir::getUserSkinDir() const
+const std::string &LLDir::getUserDefaultSkinDir() const
 {
-	return mUserSkinDir;
+    return mUserDefaultSkinDir;
 }
 
-const std::string& LLDir::getDefaultSkinDir() const
+const std::string &LLDir::getUserSkinDir() const
 {
-	return mDefaultSkinDir;
+	return mUserSkinDir;
 }
 
 const std::string LLDir::getSkinBaseDir() const
@@ -323,6 +341,41 @@ const std::string &LLDir::getLLPluginDir() const
 	return mLLPluginDir;
 }
 
+static std::string ELLPathToString(ELLPath location)
+{
+    typedef std::map<ELLPath, const char*> ELLPathMap;
+#define ENT(symbol) ELLPathMap::value_type(symbol, #symbol)
+    static ELLPathMap::value_type init[] =
+    {
+        ENT(LL_PATH_NONE),
+        ENT(LL_PATH_USER_SETTINGS),
+        ENT(LL_PATH_APP_SETTINGS),
+        ENT(LL_PATH_PER_SL_ACCOUNT), // returns/expands to blank string if we don't know the account name yet
+        ENT(LL_PATH_CACHE),
+        ENT(LL_PATH_CHARACTER),
+        ENT(LL_PATH_HELP),
+        ENT(LL_PATH_LOGS),
+        ENT(LL_PATH_TEMP),
+        ENT(LL_PATH_SKINS),
+        ENT(LL_PATH_TOP_SKIN),
+        ENT(LL_PATH_CHAT_LOGS),
+        ENT(LL_PATH_PER_ACCOUNT_CHAT_LOGS),
+        ENT(LL_PATH_USER_SKIN),
+        ENT(LL_PATH_LOCAL_ASSETS),
+        ENT(LL_PATH_EXECUTABLE),
+        ENT(LL_PATH_DEFAULT_SKIN),
+        ENT(LL_PATH_FONTS),
+        ENT(LL_PATH_LAST)
+    };
+#undef ENT
+    static const ELLPathMap sMap(boost::begin(init), boost::end(init));
+
+    ELLPathMap::const_iterator found = sMap.find(location);
+    if (found != sMap.end())
+        return found->second;
+    return STRINGIZE("Invalid ELLPath value " << location);
+}
+
 std::string LLDir::getExpandedFilename(ELLPath location, const std::string& filename) const
 {
 	return getExpandedFilename(location, "", filename);
@@ -343,15 +396,11 @@ std::string LLDir::getExpandedFilename(ELLPath location, const std::string& subd
 		break;
 
 	case LL_PATH_APP_SETTINGS:
-		prefix = getAppRODataDir();
-		prefix += mDirDelimiter;
-		prefix += "app_settings";
+		prefix = add(getAppRODataDir(), "app_settings");
 		break;
 	
 	case LL_PATH_CHARACTER:
-		prefix = getAppRODataDir();
-		prefix += mDirDelimiter;
-		prefix += "character";
+		prefix = add(getAppRODataDir(), "character");
 		break;
 		
 	case LL_PATH_HELP:
@@ -363,16 +412,22 @@ std::string LLDir::getExpandedFilename(ELLPath location, const std::string& subd
 		break;
 		
 	case LL_PATH_USER_SETTINGS:
-		prefix = getOSUserAppDir();
-		prefix += mDirDelimiter;
-		prefix += "user_settings";
+		prefix = add(getOSUserAppDir(), "user_settings");
 		break;
 
 	case LL_PATH_PER_SL_ACCOUNT:
 		prefix = getLindenUserDir();
 		if (prefix.empty())
 		{
-			// if we're asking for the per-SL-account directory but we haven't logged in yet (or otherwise don't know the account name from which to build this string), then intentionally return a blank string to the caller and skip the below warning about a blank prefix.
+			// if we're asking for the per-SL-account directory but we haven't
+			// logged in yet (or otherwise don't know the account name from
+			// which to build this string), then intentionally return a blank
+			// string to the caller and skip the below warning about a blank
+			// prefix.
+			LL_DEBUGS("LLDir") << "getLindenUserDir() not yet set: "
+							   << ELLPathToString(location)
+							   << ", '" << subdir1 << "', '" << subdir2 << "', '" << in_filename
+							   << "' => ''" << LL_ENDL;
 			return std::string();
 		}
 		break;
@@ -386,9 +441,7 @@ std::string LLDir::getExpandedFilename(ELLPath location, const std::string& subd
 		break;
 
 	case LL_PATH_LOGS:
-		prefix = getOSUserAppDir();
-		prefix += mDirDelimiter;
-		prefix += "logs";
+		prefix = add(getOSUserAppDir(), "logs");
 		break;
 
 	case LL_PATH_TEMP:
@@ -412,9 +465,7 @@ std::string LLDir::getExpandedFilename(ELLPath location, const std::string& subd
 		break;
 
 	case LL_PATH_LOCAL_ASSETS:
-		prefix = getAppRODataDir();
-		prefix += mDirDelimiter;
-		prefix += "local_assets";
+		prefix = add(getAppRODataDir(), "local_assets");
 		break;
 
 	case LL_PATH_EXECUTABLE:
@@ -422,56 +473,36 @@ std::string LLDir::getExpandedFilename(ELLPath location, const std::string& subd
 		break;
 		
 	case LL_PATH_FONTS:
-		prefix = getAppRODataDir();
-		prefix += mDirDelimiter;
-		prefix += "fonts";
+		prefix = add(getAppRODataDir(), "fonts");
 		break;
 		
 	default:
 		llassert(0);
 	}
 
-	std::string filename = in_filename;
-	if (!subdir2.empty())
-	{
-		filename = subdir2 + mDirDelimiter + filename;
-	}
-
-	if (!subdir1.empty())
-	{
-		filename = subdir1 + mDirDelimiter + filename;
-	}
-
 	if (prefix.empty())
 	{
-		llwarns << "prefix is empty, possible bad filename" << llendl;
-	}
-	
-	std::string expanded_filename;
-	if (!filename.empty())
-	{
-		if (!prefix.empty())
-		{
-			expanded_filename += prefix;
-			expanded_filename += mDirDelimiter;
-			expanded_filename += filename;
-		}
-		else
-		{
-			expanded_filename = filename;
-		}
-	}
-	else if (!prefix.empty())
-	{
-		// Directory only, no file name.
-		expanded_filename = prefix;
+		llwarns << ELLPathToString(location)
+				<< ", '" << subdir1 << "', '" << subdir2 << "', '" << in_filename
+				<< "': prefix is empty, possible bad filename" << llendl;
 	}
-	else
+
+	std::string expanded_filename = add(add(prefix, subdir1), subdir2);
+	if (expanded_filename.empty() && in_filename.empty())
 	{
-		expanded_filename.assign("");
+		return "";
 	}
-
-	//llinfos << "*** EXPANDED FILENAME: <" << expanded_filename << ">" << llendl;
+	// Use explicit concatenation here instead of another add() call. Callers
+	// passing in_filename as "" expect to obtain a pathname ending with
+	// mDirSeparator so they can later directly concatenate with a specific
+	// filename. A caller using add() doesn't care, but there's still code
+	// loose in the system that uses std::string::operator+().
+	expanded_filename += mDirDelimiter;
+	expanded_filename += in_filename;
+
+	LL_DEBUGS("LLDir") << ELLPathToString(location)
+					   << ", '" << subdir1 << "', '" << subdir2 << "', '" << in_filename
+					   << "' => '" << expanded_filename << "'" << LL_ENDL;
 	return expanded_filename;
 }
 
@@ -511,31 +542,168 @@ std::string LLDir::getExtension(const std::string& filepath) const
 	return exten;
 }
 
-std::string LLDir::findSkinnedFilename(const std::string &filename) const
+std::string LLDir::findSkinnedFilenameBaseLang(const std::string &subdir,
+											   const std::string &filename,
+											   bool merge) const
 {
-	return findSkinnedFilename("", "", filename);
+	// This implementation is basically just as described in the declaration comments.
+	std::vector<std::string> found(findSkinnedFilenames(subdir, filename, merge));
+	if (found.empty())
+	{
+		return "";
+	}
+	return found.front();
 }
 
-std::string LLDir::findSkinnedFilename(const std::string &subdir, const std::string &filename) const
+std::string LLDir::findSkinnedFilename(const std::string &subdir,
+									   const std::string &filename,
+									   bool merge) const
 {
-	return findSkinnedFilename("", subdir, filename);
+	// This implementation is basically just as described in the declaration comments.
+	std::vector<std::string> found(findSkinnedFilenames(subdir, filename, merge));
+	if (found.empty())
+	{
+		return "";
+	}
+	return found.back();
 }
 
-std::string LLDir::findSkinnedFilename(const std::string &subdir1, const std::string &subdir2, const std::string &filename) const
+std::vector<std::string> LLDir::findSkinnedFilenames(const std::string& subdir,
+													 const std::string& filename,
+													 bool merge) const
 {
-	// generate subdirectory path fragment, e.g. "/foo/bar", "/foo", ""
-	std::string subdirs = ((subdir1.empty() ? "" : mDirDelimiter) + subdir1)
-						 + ((subdir2.empty() ? "" : mDirDelimiter) + subdir2);
+	// Recognize subdirs that have no localization.
+	static const char* sUnlocalizedData[] =
+	{
+		"",							// top-level directory not localized
+		"textures"					// textures not localized
+	};
+	static const std::set<std::string> sUnlocalized(boost::begin(sUnlocalizedData),
+													boost::end(sUnlocalizedData));
+
+	LL_DEBUGS("LLDir") << "subdir '" << subdir << "', filename '" << filename
+					   << "', merge " << std::boolalpha << merge << LL_ENDL;
+
+	// Cache the default language directory for each subdir we've encountered.
+	// A cache entry whose value is the empty string means "not localized,
+	// don't bother checking again."
+	typedef std::map<std::string, std::string> LocalizedMap;
+	static LocalizedMap sLocalized;
+
+	// Check whether we've already discovered if this subdir is localized.
+	LocalizedMap::const_iterator found = sLocalized.find(subdir);
+	if (found == sLocalized.end())
+	{
+		// We have not yet determined that. Is it one of the subdirs "known"
+		// to be unlocalized?
+		if (sUnlocalized.find(subdir) != sUnlocalized.end())
+		{
+			// This subdir is known to be unlocalized. Remember that.
+			found = sLocalized.insert(LocalizedMap::value_type(subdir, "")).first;
+		}
+		else
+		{
+			// We do not recognize this subdir. Investigate.
+			std::string subdir_path(add(getDefaultSkinDir(), subdir));
+			if (fileExists(add(subdir_path, "en")))
+			{
+				// defaultSkinDir/subdir contains subdir "en". That's our
+				// default language; this subdir is localized. 
+				found = sLocalized.insert(LocalizedMap::value_type(subdir, "en")).first;
+			}
+			else if (fileExists(add(subdir_path, "en-us")))
+			{
+				// defaultSkinDir/subdir contains subdir "en-us" but not "en".
+				// Set as default language; this subdir is localized.
+				found = sLocalized.insert(LocalizedMap::value_type(subdir, "en-us")).first;
+			}
+			else
+			{
+				// defaultSkinDir/subdir contains neither "en" nor "en-us".
+				// Assume it's not localized. Remember that assumption.
+				found = sLocalized.insert(LocalizedMap::value_type(subdir, "")).first;
+			}
+		}
+	}
+	// Every code path above should have resulted in 'found' becoming a valid
+	// iterator to an entry in sLocalized.
+	llassert(found != sLocalized.end());
+
+	// Now -- is this subdir localized, or not? The answer determines what
+	// subdirectories we check (under subdir) for the requested filename.
+	std::vector<std::string> subsubdirs;
+	if (found->second.empty())
+	{
+		// subdir is not localized. filename should be located directly within it.
+		subsubdirs.push_back("");
+	}
+	else
+	{
+		// subdir is localized, and found->second is the default language
+		// directory within it. Check both the default language and the
+		// current language -- if it differs from the default, of course.
+		subsubdirs.push_back(found->second);
+		if (mLanguage != found->second)
+		{
+			subsubdirs.push_back(mLanguage);
+		}
+	}
+	// Code below relies on subsubdirs not being empty: more specifically, on
+	// front() being valid. There may or may not be additional entries, but we
+	// have at least one. For an unlocalized subdir, it's the only one; for a
+	// localized subdir, it's the default one.
+	llassert(! subsubdirs.empty());
+
+	// Build results vector.
+	std::vector<std::string> results;
+	BOOST_FOREACH(std::string skindir, mSearchSkinDirs)
+	{
+		std::string subdir_path(add(skindir, subdir));
+		// Does subdir_path/subsubdirs[0]/filename exist? If there's more than
+		// one entry in subsubdirs, the first is the default language ("en"),
+		// the second is the current language. A skin that contains
+		// subdir/language/filename without also containing subdir/en/filename
+		// is ill-formed: skip any such skin. So to decide whether to keep
+		// this skin dir or skip it, we need only check for the existence of
+		// the first subsubdir entry ("en" or only).
+		std::string subsubdir_path(add(add(subdir_path, subsubdirs.front()), filename));
+		if (! fileExists(subsubdir_path))
+			continue;
 
-	std::vector<std::string> search_paths;
-	
-	search_paths.push_back(getUserSkinDir() + subdirs);		// first look in user skin override
-	search_paths.push_back(getSkinDir() + subdirs);			// then in current skin
-	search_paths.push_back(getDefaultSkinDir() + subdirs);  // then default skin
-	search_paths.push_back(getCacheDir() + subdirs);		// and last in preload directory
+		// Here the desired filename exists in the first subsubdir. That means
+		// this is a skindir we want to record in results. But if the caller
+		// passed merge=false, we must discard all previous skindirs.
+		if (! merge)
+		{
+			results.clear();
+		}
+
+		// Now add every subsubdir in which filename exists. We already know
+		// it exists in the first one.
+		results.push_back(subsubdir_path);
+
+		// Append all remaining subsubdirs in which filename exists.
+		for (std::vector<std::string>::const_iterator ssdi(subsubdirs.begin() + 1), ssdend(subsubdirs.end());
+			 ssdi != ssdend; ++ssdi)
+		{
+			subsubdir_path = add(add(subdir_path, *ssdi), filename);
+			if (fileExists(subsubdir_path))
+			{
+				results.push_back(subsubdir_path);
+			}
+		}
+	}
 
-	std::string found_file = findFile(filename, search_paths);
-	return found_file;
+	LL_DEBUGS("LLDir") << empty;
+	const char* comma = "";
+	BOOST_FOREACH(std::string path, results)
+	{
+		LL_CONT << comma << "'" << path << "'";
+		comma = ", ";
+	}
+	LL_CONT << LL_ENDL;
+
+	return results;
 }
 
 std::string LLDir::getTempFilename() const
@@ -546,12 +714,7 @@ std::string LLDir::getTempFilename() const
 	random_uuid.generate();
 	random_uuid.toString(uuid_str);
 
-	std::string temp_filename = getTempDir();
-	temp_filename += mDirDelimiter;
-	temp_filename += uuid_str;
-	temp_filename += ".tmp";
-
-	return temp_filename;
+	return add(getTempDir(), uuid_str + ".tmp");
 }
 
 // static
@@ -587,9 +750,7 @@ void LLDir::setLindenUserDir(const std::string &username)
 		std::string userlower(username);
 		LLStringUtil::toLower(userlower);
 		LLStringUtil::replaceChar(userlower, ' ', '_');
-		mLindenUserDir = getOSUserAppDir();
-		mLindenUserDir += mDirDelimiter;
-		mLindenUserDir += userlower;
+		mLindenUserDir = add(getOSUserAppDir(), userlower);
 	}
 	else
 	{
@@ -621,9 +782,7 @@ void LLDir::setPerAccountChatLogsDir(const std::string &username)
 		std::string userlower(username);
 		LLStringUtil::toLower(userlower);
 		LLStringUtil::replaceChar(userlower, ' ', '_');
-		mPerAccountChatLogsDir = getChatLogsDir();
-		mPerAccountChatLogsDir += mDirDelimiter;
-		mPerAccountChatLogsDir += userlower;
+		mPerAccountChatLogsDir = add(getChatLogsDir(), userlower);
 	}
 	else
 	{
@@ -632,25 +791,59 @@ void LLDir::setPerAccountChatLogsDir(const std::string &username)
 	
 }
 
-void LLDir::setSkinFolder(const std::string &skin_folder)
+void LLDir::setSkinFolder(const std::string &skin_folder, const std::string& language)
 {
-	mSkinDir = getSkinBaseDir();
-	mSkinDir += mDirDelimiter;
-	mSkinDir += skin_folder;
+	LL_DEBUGS("LLDir") << "Setting skin '" << skin_folder << "', language '" << language << "'"
+					   << LL_ENDL;
+	mSkinName = skin_folder;
+	mLanguage = language;
 
-	// user modifications to current skin
-	// e.g. c:\documents and settings\users\username\application data\second life\skins\dazzle
-	mUserSkinDir = getOSUserAppDir();
-	mUserSkinDir += mDirDelimiter;
-	mUserSkinDir += "skins";
-	mUserSkinDir += mDirDelimiter;	
-	mUserSkinDir += skin_folder;
+	// This method is called multiple times during viewer initialization. Each
+	// time it's called, reset mSearchSkinDirs.
+	mSearchSkinDirs.clear();
 
 	// base skin which is used as fallback for all skinned files
 	// e.g. c:\program files\secondlife\skins\default
 	mDefaultSkinDir = getSkinBaseDir();
-	mDefaultSkinDir += mDirDelimiter;	
-	mDefaultSkinDir += "default";
+	append(mDefaultSkinDir, "default");
+	// This is always the most general of the search skin directories.
+	addSearchSkinDir(mDefaultSkinDir);
+
+	mSkinDir = getSkinBaseDir();
+	append(mSkinDir, skin_folder);
+	// Next level of generality is a skin installed with the viewer.
+	addSearchSkinDir(mSkinDir);
+
+	// user modifications to skins, current and default
+	// e.g. c:\documents and settings\users\username\application data\second life\skins\dazzle
+	mUserSkinDir = getOSUserAppDir();
+	append(mUserSkinDir, "skins");
+	mUserDefaultSkinDir = mUserSkinDir;
+	append(mUserDefaultSkinDir, "default");
+	append(mUserSkinDir, skin_folder);
+	// Next level of generality is user modifications to default skin...
+	addSearchSkinDir(mUserDefaultSkinDir);
+	// then user-defined skins.
+	addSearchSkinDir(mUserSkinDir);
+}
+
+void LLDir::addSearchSkinDir(const std::string& skindir)
+{
+	if (std::find(mSearchSkinDirs.begin(), mSearchSkinDirs.end(), skindir) == mSearchSkinDirs.end())
+	{
+		LL_DEBUGS("LLDir") << "search skin: '" << skindir << "'" << LL_ENDL;
+		mSearchSkinDirs.push_back(skindir);
+	}
+}
+
+std::string LLDir::getSkinFolder() const
+{
+	return mSkinName;
+}
+
+std::string LLDir::getLanguage() const
+{
+	return mLanguage;
 }
 
 bool LLDir::setCacheDir(const std::string &path)
@@ -664,7 +857,7 @@ bool LLDir::setCacheDir(const std::string &path)
 	else
 	{
 		LLFile::mkdir(path);
-		std::string tempname = path + mDirDelimiter + "temp";
+		std::string tempname = add(path, "temp");
 		LLFILE* file = LLFile::fopen(tempname,"wt");
 		if (file)
 		{
@@ -697,6 +890,57 @@ void LLDir::dumpCurrentDirectories()
 	LL_DEBUGS2("AppInit","Directories") << "  SkinDir:               " << getSkinDir() << LL_ENDL;
 }
 
+std::string LLDir::add(const std::string& path, const std::string& name) const
+{
+	std::string destpath(path);
+	append(destpath, name);
+	return destpath;
+}
+
+void LLDir::append(std::string& destpath, const std::string& name) const
+{
+	// Delegate question of whether we need a separator to helper method.
+	SepOff sepoff(needSep(destpath, name));
+	if (sepoff.first)               // do we need a separator?
+	{
+		destpath += mDirDelimiter;
+	}
+	// If destpath ends with a separator, AND name starts with one, skip
+	// name's leading separator.
+	destpath += name.substr(sepoff.second);
+}
+
+LLDir::SepOff LLDir::needSep(const std::string& path, const std::string& name) const
+{
+	if (path.empty() || name.empty())
+	{
+		// If either path or name are empty, we do not need a separator
+		// between them.
+		return SepOff(false, 0);
+	}
+	// Here we know path and name are both non-empty. But if path already ends
+	// with a separator, or if name already starts with a separator, we need
+	// not add one.
+	std::string::size_type seplen(mDirDelimiter.length());
+	bool path_ends_sep(path.substr(path.length() - seplen) == mDirDelimiter);
+	bool name_starts_sep(name.substr(0, seplen) == mDirDelimiter);
+	if ((! path_ends_sep) && (! name_starts_sep))
+	{
+		// If neither path nor name brings a separator to the junction, then
+		// we need one.
+		return SepOff(true, 0);
+	}
+	if (path_ends_sep && name_starts_sep)
+	{
+		// But if BOTH path and name bring a separator, we need not add one.
+		// Moreover, we should actually skip the leading separator of 'name'.
+		return SepOff(false, seplen);
+	}
+	// Here we know that either path_ends_sep or name_starts_sep is true --
+	// but not both. So don't add a separator, and don't skip any characters:
+	// simple concatenation will do the trick.
+	return SepOff(false, 0);
+}
 
 void dir_exists_or_crash(const std::string &dir_name)
 {
diff --git a/indra/llvfs/lldir.h b/indra/llvfs/lldir.h
index 5ee8bdb542..a242802979 100644
--- a/indra/llvfs/lldir.h
+++ b/indra/llvfs/lldir.h
@@ -56,7 +56,7 @@ typedef enum ELLPath
 	LL_PATH_LAST
 } ELLPath;
 
-
+/// Directory operations
 class LLDir
 {
  public:
@@ -100,9 +100,10 @@ class LLDir
 	const std::string &getOSCacheDir() const;		// location of OS-specific cache folder (may be empty string)
 	const std::string &getCAFile() const;			// File containing TLS certificate authorities
 	const std::string &getDirDelimiter() const;	// directory separator for platform (ie. '\' or '/' or ':')
+	const std::string &getDefaultSkinDir() const;	// folder for default skin. e.g. c:\program files\second life\skins\default
 	const std::string &getSkinDir() const;		// User-specified skin folder.
+	const std::string &getUserDefaultSkinDir() const; // dir with user modifications to default skin
 	const std::string &getUserSkinDir() const;		// User-specified skin folder with user modifications. e.g. c:\documents and settings\username\application data\second life\skins\curskin
-	const std::string &getDefaultSkinDir() const;	// folder for default skin. e.g. c:\program files\second life\skins\default
 	const std::string getSkinBaseDir() const;		// folder that contains all installed skins (not user modifications). e.g. c:\program files\second life\skins
 	const std::string &getLLPluginDir() const;		// Directory containing plugins and plugin shell
 
@@ -117,10 +118,59 @@ class LLDir
 	std::string getExtension(const std::string& filepath) const; // Excludes '.', e.g getExtension("foo.wav") == "wav"
 
 	// these methods search the various skin paths for the specified file in the following order:
-	// getUserSkinDir(), getSkinDir(), getDefaultSkinDir()
-	std::string findSkinnedFilename(const std::string &filename) const;
-	std::string findSkinnedFilename(const std::string &subdir, const std::string &filename) const;
-	std::string findSkinnedFilename(const std::string &subdir1, const std::string &subdir2, const std::string &filename) const;
+	// getUserSkinDir(), getUserDefaultSkinDir(), getSkinDir(), getDefaultSkinDir()
+	/**
+	 * Given a filename within skin, return an ordered sequence of paths to
+	 * search. Nonexistent files will be filtered out -- which means that the
+	 * vector might be empty.
+	 *
+	 * @param subdir Identify top-level skin subdirectory by passing one of
+	 * LLDir::XUI (file lives under "xui" subtree), LLDir::TEXTURES (file
+	 * lives under "textures" subtree), LLDir::SKINBASE (file lives at top
+	 * level of skin subdirectory).
+	 * @param filename Desired filename within subdir within skin, e.g.
+	 * "panel_login.xml". DO NOT prepend (e.g.) "xui" or the desired language.
+	 * @param merge Callers perform two different kinds of processing. When
+	 * fetching a XUI file, for instance, the existence of @a filename in the
+	 * specified skin completely supercedes any @a filename in the default
+	 * skin. For that case, leave the default @a merge=false. The returned
+	 * vector will contain only
+	 * ".../<i>current_skin</i>/xui/en/<i>filename</i>",
+	 * ".../<i>current_skin</i>/xui/<i>current_language</i>/<i>filename</i>".
+	 * But for (e.g.) "strings.xml", we want a given skin to be able to
+	 * override only specific entries from the default skin. Any string not
+	 * defined in the specified skin will be sought in the default skin. For
+	 * that case, pass @a merge=true. The returned vector will contain at
+	 * least ".../default/xui/en/strings.xml",
+	 * ".../default/xui/<i>current_language</i>/strings.xml",
+	 * ".../<i>current_skin</i>/xui/en/strings.xml",
+	 * ".../<i>current_skin</i>/xui/<i>current_language</i>/strings.xml".
+	 */
+	std::vector<std::string> findSkinnedFilenames(const std::string& subdir,
+												  const std::string& filename,
+												  bool merge=false) const;
+	/// Values for findSkinnedFilenames(subdir) parameter
+	static const char *XUI, *TEXTURES, *SKINBASE;
+	/**
+	 * Return the base-language pathname from findSkinnedFilenames(), or
+	 * the empty string if no such file exists. Parameters are identical to
+	 * findSkinnedFilenames(). This is shorthand for capturing the vector
+	 * returned by findSkinnedFilenames(), checking for empty() and then
+	 * returning front().
+	 */
+	std::string findSkinnedFilenameBaseLang(const std::string &subdir,
+											const std::string &filename,
+											bool merge=false) const;
+	/**
+	 * Return the "most localized" pathname from findSkinnedFilenames(), or
+	 * the empty string if no such file exists. Parameters are identical to
+	 * findSkinnedFilenames(). This is shorthand for capturing the vector
+	 * returned by findSkinnedFilenames(), checking for empty() and then
+	 * returning back().
+	 */
+	std::string findSkinnedFilename(const std::string &subdir,
+									const std::string &filename,
+									bool merge=false) const;
 
 	// random filename in common temporary directory
 	std::string getTempFilename() const;
@@ -132,15 +182,30 @@ class LLDir
 	virtual void setChatLogsDir(const std::string &path);		// Set the chat logs dir to this user's dir
 	virtual void setPerAccountChatLogsDir(const std::string &username);		// Set the per user chat log directory.
 	virtual void setLindenUserDir(const std::string &username);		// Set the linden user dir to this user's dir
-	virtual void setSkinFolder(const std::string &skin_folder);
+	virtual void setSkinFolder(const std::string &skin_folder, const std::string& language);
+	virtual std::string getSkinFolder() const;
+	virtual std::string getLanguage() const;
 	virtual bool setCacheDir(const std::string &path);
 
 	virtual void dumpCurrentDirectories();
-	
+
 	// Utility routine
 	std::string buildSLOSCacheDir() const;
 
+	/// Append specified @a name to @a destpath, separated by getDirDelimiter()
+	/// if both are non-empty.
+	void append(std::string& destpath, const std::string& name) const;
+	/// Append specified @a name to @a path, separated by getDirDelimiter()
+	/// if both are non-empty. Return result, leaving @a path unmodified.
+	std::string add(const std::string& path, const std::string& name) const;
+
 protected:
+	// Does an add() or append() call need a directory delimiter?
+	typedef std::pair<bool, unsigned short> SepOff;
+	SepOff needSep(const std::string& path, const std::string& name) const;
+	// build mSearchSkinDirs without adding duplicates
+	void addSearchSkinDir(const std::string& skindir);
+
 	std::string mAppName;               // install directory under progams/ ie "SecondLife"   
 	std::string mExecutablePathAndName; // full path + Filename of .exe
 	std::string mExecutableFilename;    // Filename of .exe
@@ -158,10 +223,18 @@ protected:
 	std::string mDefaultCacheDir;	// default cache diretory
 	std::string mOSCacheDir;		// operating system cache dir
 	std::string mDirDelimiter;
+	std::string mSkinName;           // caller-specified skin name
 	std::string mSkinBaseDir;			// Base for skins paths.
-	std::string mSkinDir;			// Location for current skin info.
 	std::string mDefaultSkinDir;			// Location for default skin info.
+	std::string mSkinDir;			// Location for current skin info.
+	std::string mUserDefaultSkinDir;		// Location for default skin info.
 	std::string mUserSkinDir;			// Location for user-modified skin info.
+	// Skin directories to search, most general to most specific. This order
+	// works well for composing fine-grained files, in which an individual item
+	// in a specific file overrides the corresponding item in more general
+	// files. Of course, for a file-level search, iterate backwards.
+	std::vector<std::string> mSearchSkinDirs;
+	std::string mLanguage;              // Current viewer language
 	std::string mLLPluginDir;			// Location for plugins and plugin shell
 };
 
diff --git a/indra/llvfs/tests/lldir_test.cpp b/indra/llvfs/tests/lldir_test.cpp
index ea321c5ae9..a00fc8684c 100644
--- a/indra/llvfs/tests/lldir_test.cpp
+++ b/indra/llvfs/tests/lldir_test.cpp
@@ -27,11 +27,161 @@
 
 #include "linden_common.h"
 
+#include "llstring.h"
+#include "tests/StringVec.h"
 #include "../lldir.h"
 #include "../lldiriterator.h"
 
 #include "../test/lltut.h"
+#include "stringize.h"
+#include <boost/foreach.hpp>
+#include <boost/assign/list_of.hpp>
+
+using boost::assign::list_of;
+
+// We use ensure_equals(..., vec(list_of(...))) not because it's functionally
+// required, but because ensure_equals() knows how to format a StringVec.
+// Turns out that when ensure_equals() displays a test failure with just
+// list_of("string")("another"), you see 'stringanother' vs. '("string",
+// "another")'.
+StringVec vec(const StringVec& v)
+{
+    return v;
+}
 
+// For some tests, use a dummy LLDir that uses memory data instead of touching
+// the filesystem
+struct LLDir_Dummy: public LLDir
+{
+    /*----------------------------- LLDir API ------------------------------*/
+    LLDir_Dummy()
+    {
+        // Initialize important LLDir data members based on the filesystem
+        // data below.
+        mDirDelimiter = "/";
+        mExecutableDir = "install";
+        mExecutableFilename = "test";
+        mExecutablePathAndName = add(mExecutableDir, mExecutableFilename);
+        mWorkingDir = mExecutableDir;
+        mAppRODataDir = "install";
+        mSkinBaseDir = add(mAppRODataDir, "skins");
+        mOSUserDir = "user";
+        mOSUserAppDir = mOSUserDir;
+        mLindenUserDir = "";
+
+        // Make the dummy filesystem look more or less like what we expect in
+        // the real one.
+        static const char* preload[] =
+        {
+            "install/skins/default/colors.xml",
+            "install/skins/default/xui/en/strings.xml",
+            "install/skins/default/xui/fr/strings.xml",
+            "install/skins/default/xui/en/floater.xml",
+            "install/skins/default/xui/fr/floater.xml",
+            "install/skins/default/xui/en/newfile.xml",
+            "install/skins/default/xui/fr/newfile.xml",
+            "install/skins/default/html/en-us/welcome.html",
+            "install/skins/default/html/fr/welcome.html",
+            "install/skins/default/textures/only_default.jpeg",
+            "install/skins/default/future/somefile.txt",
+            "install/skins/steam/colors.xml",
+            "install/skins/steam/xui/en/strings.xml",
+            "install/skins/steam/xui/fr/strings.xml",
+            "install/skins/steam/textures/only_steam.jpeg",
+            "user/skins/default/colors.xml",
+            "user/skins/default/xui/en/strings.xml",
+            "user/skins/default/xui/fr/strings.xml",
+            // This is an attempted override that doesn't work: for a
+            // localized subdir, a skin must have subdir/en/filename as well
+            // as subdir/language/filename.
+            "user/skins/default/xui/fr/floater.xml",
+            // This is an override that only specifies the "en" version
+            "user/skins/default/xui/en/newfile.xml",
+            "user/skins/default/textures/only_user_default.jpeg",
+            "user/skins/steam/colors.xml",
+            "user/skins/steam/xui/en/strings.xml",
+            "user/skins/steam/xui/fr/strings.xml",
+            "user/skins/steam/textures/only_user_steam.jpeg"
+        };
+        BOOST_FOREACH(const char* path, preload)
+        {
+            buildFilesystem(path);
+        }
+    }
+
+    virtual ~LLDir_Dummy() {}
+
+    virtual void initAppDirs(const std::string& app_name, const std::string& app_read_only_data_dir)
+    {
+        // Implement this when we write a test that needs it
+    }
+
+    virtual std::string getCurPath()
+    {
+        // Implement this when we write a test that needs it
+        return "";
+    }
+
+    virtual U32 countFilesInDir(const std::string& dirname, const std::string& mask)
+    {
+        // Implement this when we write a test that needs it
+        return 0;
+    }
+
+    virtual BOOL fileExists(const std::string& pathname) const
+    {
+        // Record fileExists() calls so we can check whether caching is
+        // working right. Certain LLDir calls should be able to make decisions
+        // without calling fileExists() again, having already checked existence.
+        mChecked.insert(pathname);
+        // For our simple flat set of strings, see whether the identical
+        // pathname exists in our set.
+        return (mFilesystem.find(pathname) != mFilesystem.end());
+    }
+
+    virtual std::string getLLPluginLauncher()
+    {
+        // Implement this when we write a test that needs it
+        return "";
+    }
+
+    virtual std::string getLLPluginFilename(std::string base_name)
+    {
+        // Implement this when we write a test that needs it
+        return "";
+    }
+
+    /*----------------------------- Dummy data -----------------------------*/
+    void clearFilesystem() { mFilesystem.clear(); }
+    void buildFilesystem(const std::string& path)
+    {
+        // Split the pathname on slashes, ignoring leading, trailing, doubles
+        StringVec components;
+        LLStringUtil::getTokens(path, components, "/");
+        // Ensure we have an entry representing every level of this path
+        std::string partial;
+        BOOST_FOREACH(std::string component, components)
+        {
+            append(partial, component);
+            mFilesystem.insert(partial);
+        }
+    }
+
+    void clear_checked() { mChecked.clear(); }
+    void ensure_checked(const std::string& pathname) const
+    {
+        tut::ensure(STRINGIZE(pathname << " was not checked but should have been"),
+                    mChecked.find(pathname) != mChecked.end());
+    }
+    void ensure_not_checked(const std::string& pathname) const
+    {
+        tut::ensure(STRINGIZE(pathname << " was checked but should not have been"),
+                    mChecked.find(pathname) == mChecked.end());
+    }
+
+    std::set<std::string> mFilesystem;
+    mutable std::set<std::string> mChecked;
+};
 
 namespace tut
 {
@@ -419,5 +569,192 @@ namespace tut
       LLFile::rmdir(dir1);
       LLFile::rmdir(dir2);
    }
-}
 
+    template<> template<>
+    void LLDirTest_object_t::test<6>()
+    {
+        set_test_name("findSkinnedFilenames()");
+        LLDir_Dummy lldir;
+        /*------------------------ "default", "en" -------------------------*/
+        // Setting "default" means we shouldn't consider any "*/skins/steam"
+        // directories; setting "en" means we shouldn't consider any "xui/fr"
+        // directories.
+        lldir.setSkinFolder("default", "en");
+        ensure_equals(lldir.getSkinFolder(), "default");
+        ensure_equals(lldir.getLanguage(), "en");
+
+        // top-level directory of a skin isn't localized
+        ensure_equals(lldir.findSkinnedFilenames(LLDir::SKINBASE, "colors.xml", true),
+                      vec(list_of("install/skins/default/colors.xml")
+                                 ("user/skins/default/colors.xml")));
+        // We should not have needed to check for skins/default/en. We should
+        // just "know" that SKINBASE is not localized.
+        lldir.ensure_not_checked("install/skins/default/en");
+
+        ensure_equals(lldir.findSkinnedFilenames(LLDir::TEXTURES, "only_default.jpeg"),
+                      vec(list_of("install/skins/default/textures/only_default.jpeg")));
+        // Nor should we have needed to check skins/default/textures/en
+        // because textures is known to be unlocalized.
+        lldir.ensure_not_checked("install/skins/default/textures/en");
+
+        StringVec expected(vec(list_of("install/skins/default/xui/en/strings.xml")
+                               ("user/skins/default/xui/en/strings.xml")));
+        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "strings.xml", true),
+                      expected);
+        // The first time, we had to probe to find out whether xui was localized.
+        lldir.ensure_checked("install/skins/default/xui/en");
+        lldir.clear_checked();
+        // Now make the same call again -- should return same result --
+        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "strings.xml", true),
+                      expected);
+        // but this time it should remember that xui is localized.
+        lldir.ensure_not_checked("install/skins/default/xui/en");
+
+        // localized subdir with "en-us" instead of "en"
+        ensure_equals(lldir.findSkinnedFilenames("html", "welcome.html"),
+                      vec(list_of("install/skins/default/html/en-us/welcome.html")));
+        lldir.ensure_checked("install/skins/default/html/en");
+        lldir.ensure_checked("install/skins/default/html/en-us");
+        lldir.clear_checked();
+        ensure_equals(lldir.findSkinnedFilenames("html", "welcome.html"),
+                      vec(list_of("install/skins/default/html/en-us/welcome.html")));
+        lldir.ensure_not_checked("install/skins/default/html/en");
+        lldir.ensure_not_checked("install/skins/default/html/en-us");
+
+        ensure_equals(lldir.findSkinnedFilenames("future", "somefile.txt"),
+                      vec(list_of("install/skins/default/future/somefile.txt")));
+        // Test probing for an unrecognized unlocalized future subdir.
+        lldir.ensure_checked("install/skins/default/future/en");
+        lldir.clear_checked();
+        ensure_equals(lldir.findSkinnedFilenames("future", "somefile.txt"),
+                      vec(list_of("install/skins/default/future/somefile.txt")));
+        // Second time it should remember that future is unlocalized.
+        lldir.ensure_not_checked("install/skins/default/future/en");
+
+        // When language is set to "en", requesting an html file pulls up the
+        // "en-us" version -- not because it magically matches those strings,
+        // but because there's no "en" localization and it falls back on the
+        // default "en-us"! Note that it would probably still be better to
+        // make the default localization be "en" and allow "en-gb" (or
+        // whatever) localizations, which would work much more the way you'd
+        // expect.
+        ensure_equals(lldir.findSkinnedFilenames("html", "welcome.html"),
+                      vec(list_of("install/skins/default/html/en-us/welcome.html")));
+
+        /*------------------------ "default", "fr" -------------------------*/
+        // We start being able to distinguish localized subdirs from
+        // unlocalized when we ask for a non-English language.
+        lldir.setSkinFolder("default", "fr");
+        ensure_equals(lldir.getLanguage(), "fr");
+
+        // pass merge=true to request this filename in all relevant skins
+        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "strings.xml", true),
+                      vec(list_of
+                          ("install/skins/default/xui/en/strings.xml")
+                          ("install/skins/default/xui/fr/strings.xml")
+                          ("user/skins/default/xui/en/strings.xml")
+                          ("user/skins/default/xui/fr/strings.xml")));
+
+        // pass (or default) merge=false to request only most specific skin
+        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "strings.xml"),
+                      vec(list_of
+                          ("user/skins/default/xui/en/strings.xml")
+                          ("user/skins/default/xui/fr/strings.xml")));
+
+        // The most specific skin for our dummy floater.xml is the installed
+        // default. Although we have a user xui/fr/floater.xml, we would also
+        // need a xui/en/floater.xml file to consider the user skin for this.
+        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "floater.xml"),
+                      vec(list_of
+                          ("install/skins/default/xui/en/floater.xml")
+                          ("install/skins/default/xui/fr/floater.xml")));
+
+        // The user override for the default skin does define newfile.xml, but
+        // only an "en" version, not a "fr" version as well. Nonetheless
+        // that's the most specific skin we have, regardless of the existence
+        // of a "fr" version in the installed default skin.
+        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "newfile.xml"),
+                      vec(list_of("user/skins/default/xui/en/newfile.xml")));
+
+        ensure_equals(lldir.findSkinnedFilenames("html", "welcome.html"),
+                      vec(list_of
+                          ("install/skins/default/html/en-us/welcome.html")
+                          ("install/skins/default/html/fr/welcome.html")));
+
+        /*------------------------ "default", "zh" -------------------------*/
+        lldir.setSkinFolder("default", "zh");
+        // Because the user default skins strings.xml has only a "fr" override
+        // but not a "zh" override, the most localized version we can find is "en".
+        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "strings.xml"),
+                      vec(list_of("user/skins/default/xui/en/strings.xml")));
+
+        /*------------------------- "steam", "en" --------------------------*/
+        lldir.setSkinFolder("steam", "en");
+
+        ensure_equals(lldir.findSkinnedFilenames(LLDir::SKINBASE, "colors.xml", true),
+                      vec(list_of
+                          ("install/skins/default/colors.xml")
+                          ("install/skins/steam/colors.xml")
+                          ("user/skins/default/colors.xml")
+                          ("user/skins/steam/colors.xml")));
+
+        ensure_equals(lldir.findSkinnedFilenames(LLDir::TEXTURES, "only_default.jpeg"),
+                      vec(list_of("install/skins/default/textures/only_default.jpeg")));
+
+        ensure_equals(lldir.findSkinnedFilenames(LLDir::TEXTURES, "only_steam.jpeg"),
+                      vec(list_of("install/skins/steam/textures/only_steam.jpeg")));
+
+        ensure_equals(lldir.findSkinnedFilenames(LLDir::TEXTURES, "only_user_default.jpeg"),
+                      vec(list_of("user/skins/default/textures/only_user_default.jpeg")));
+
+        ensure_equals(lldir.findSkinnedFilenames(LLDir::TEXTURES, "only_user_steam.jpeg"),
+                      vec(list_of("user/skins/steam/textures/only_user_steam.jpeg")));
+
+        // merge=false
+        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "strings.xml"),
+                      vec(list_of("user/skins/steam/xui/en/strings.xml")));
+
+        // pass merge=true to request this filename in all relevant skins
+        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "strings.xml", true),
+                      vec(list_of
+                          ("install/skins/default/xui/en/strings.xml")
+                          ("install/skins/steam/xui/en/strings.xml")
+                          ("user/skins/default/xui/en/strings.xml")
+                          ("user/skins/steam/xui/en/strings.xml")));
+
+        /*------------------------- "steam", "fr" --------------------------*/
+        lldir.setSkinFolder("steam", "fr");
+
+        // pass merge=true to request this filename in all relevant skins
+        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "strings.xml"),
+                      vec(list_of
+                          ("user/skins/steam/xui/en/strings.xml")
+                          ("user/skins/steam/xui/fr/strings.xml")));
+
+        // pass merge=true to request this filename in all relevant skins
+        ensure_equals(lldir.findSkinnedFilenames(LLDir::XUI, "strings.xml", true),
+                      vec(list_of
+                          ("install/skins/default/xui/en/strings.xml")
+                          ("install/skins/default/xui/fr/strings.xml")
+                          ("install/skins/steam/xui/en/strings.xml")
+                          ("install/skins/steam/xui/fr/strings.xml")
+                          ("user/skins/default/xui/en/strings.xml")
+                          ("user/skins/default/xui/fr/strings.xml")
+                          ("user/skins/steam/xui/en/strings.xml")
+                          ("user/skins/steam/xui/fr/strings.xml")));
+    }
+
+    template<> template<>
+    void LLDirTest_object_t::test<7>()
+    {
+        set_test_name("add()");
+        LLDir_Dummy lldir;
+        ensure_equals("both empty", lldir.add("", ""), "");
+        ensure_equals("path empty", lldir.add("", "b"), "b");
+        ensure_equals("name empty", lldir.add("a", ""), "a");
+        ensure_equals("both simple", lldir.add("a", "b"), "a/b");
+        ensure_equals("name leading slash", lldir.add("a", "/b"), "a/b");
+        ensure_equals("path trailing slash", lldir.add("a/", "b"), "a/b");
+        ensure_equals("both bring slashes", lldir.add("a/", "/b"), "a/b");
+    }
+}
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index e8934d9a9e..e7a8a52a75 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -122,7 +122,6 @@
 #include <boost/algorithm/string.hpp>
 
 
-
 #if LL_WINDOWS
 #	include <share.h> // For _SH_DENYWR in initMarkerFile
 #else
@@ -684,7 +683,7 @@ bool LLAppViewer::init()
 	gDirUtilp->initAppDirs("SecondLife");
 	// set skin search path to default, will be overridden later
 	// this allows simple skinned file lookups to work
-	gDirUtilp->setSkinFolder("default");
+	gDirUtilp->setSkinFolder("default", "en");
 
 	initLogging();
 	
@@ -768,12 +767,16 @@ bool LLAppViewer::init()
 		&LLUI::sGLScaleFactor);
 	LL_INFOS("InitInfo") << "UI initialized." << LL_ENDL ;
 
-	// Setup paths and LLTrans after LLUI::initClass has been called.
-	LLUI::setupPaths();
+	// NOW LLUI::getLanguage() should work. gDirUtilp must know the language
+	// for this session ASAP so all the file-loading commands that follow,
+	// that use findSkinnedFilenames(), will include the localized files.
+	gDirUtilp->setSkinFolder(gDirUtilp->getSkinFolder(), LLUI::getLanguage());
+
+	// Setup LLTrans after LLUI::initClass has been called.
 	LLTransUtil::parseStrings("strings.xml", default_trans_args);
 	LLTransUtil::parseLanguageStrings("language_settings.xml");
 
-	// Setup notifications after LLUI::setupPaths() has been called.
+	// Setup notifications after LLUI::initClass() has been called.
 	LLNotifications::instance();
 	LL_INFOS("InitInfo") << "Notifications initialized." << LL_ENDL ;
 
@@ -2242,8 +2245,7 @@ bool LLAppViewer::initConfiguration()
 		OSMessageBox(msg.str(),LLStringUtil::null,OSMB_OK);
 		return false;
 	}
-	
-	LLUI::setupPaths(); // setup paths for LLTrans based on settings files only
+
 	LLTransUtil::parseStrings("strings.xml", default_trans_args);
 	LLTransUtil::parseLanguageStrings("language_settings.xml");
 	// - set procedural settings
@@ -2559,13 +2561,15 @@ bool LLAppViewer::initConfiguration()
 		LLStartUp::setStartSLURL(start_slurl);
     }
 
-    const LLControlVariable* skinfolder = gSavedSettings.getControl("SkinCurrent");
-    if(skinfolder && LLStringUtil::null != skinfolder->getValue().asString())
-    {   
-		// hack to force the skin to default.
-        gDirUtilp->setSkinFolder(skinfolder->getValue().asString());
-		//gDirUtilp->setSkinFolder("default");
-    }
+	const LLControlVariable* skinfolder = gSavedSettings.getControl("SkinCurrent");
+	if(skinfolder && LLStringUtil::null != skinfolder->getValue().asString())
+	{	
+		// Examining "Language" may not suffice -- see LLUI::getLanguage()
+		// logic. Unfortunately LLUI::getLanguage() doesn't yet do us much
+		// good because we haven't yet called LLUI::initClass().
+		gDirUtilp->setSkinFolder(skinfolder->getValue().asString(),
+								 gSavedSettings.getString("Language"));
+	}
 
 	if (gSavedSettings.getBOOL("SpellCheck"))
 	{
@@ -3589,8 +3593,7 @@ void LLAppViewer::migrateCacheDirectory()
 	{
 		gSavedSettings.setBOOL("MigrateCacheDirectory", FALSE);
 
-		std::string delimiter = gDirUtilp->getDirDelimiter();
-		std::string old_cache_dir = gDirUtilp->getOSUserAppDir() + delimiter + "cache";
+		std::string old_cache_dir = gDirUtilp->add(gDirUtilp->getOSUserAppDir(), "cache");
 		std::string new_cache_dir = gDirUtilp->getCacheDir(true);
 
 		if (gDirUtilp->fileExists(old_cache_dir))
@@ -3606,8 +3609,8 @@ void LLAppViewer::migrateCacheDirectory()
 			while (iter.next(file_name))
 			{
 				if (file_name == "." || file_name == "..") continue;
-				std::string source_path = old_cache_dir + delimiter + file_name;
-				std::string dest_path = new_cache_dir + delimiter + file_name;
+				std::string source_path = gDirUtilp->add(old_cache_dir, file_name);
+				std::string dest_path = gDirUtilp->add(new_cache_dir, file_name);
 				if (!LLFile::rename(source_path, dest_path))
 				{
 					file_count++;
@@ -3838,7 +3841,7 @@ bool LLAppViewer::initCache()
 		LLDirIterator iter(dir, mask);
 		if (iter.next(found_file))
 		{
-			old_vfs_data_file = dir + gDirUtilp->getDirDelimiter() + found_file;
+			old_vfs_data_file = gDirUtilp->add(dir, found_file);
 
 			S32 start_pos = found_file.find_last_of('.');
 			if (start_pos > 0)
@@ -5149,20 +5152,20 @@ void LLAppViewer::launchUpdater()
 	// we tell the updater where to find the xml containing string
 	// translations which it can use for its own UI
 	std::string xml_strings_file = "strings.xml";
-	std::vector<std::string> xui_path_vec = LLUI::getXUIPaths();
+	std::vector<std::string> xui_path_vec =
+		gDirUtilp->findSkinnedFilenames(LLDir::XUI, xml_strings_file);
 	std::string xml_search_paths;
-	std::vector<std::string>::const_iterator iter;
+	const char* delim = "";
 	// build comma-delimited list of xml paths to pass to updater
-	for (iter = xui_path_vec.begin(); iter != xui_path_vec.end(); )
-	{
-		std::string this_skin_dir = gDirUtilp->getDefaultSkinDir()
-			+ gDirUtilp->getDirDelimiter()
-			+ (*iter);
-		llinfos << "Got a XUI path: " << this_skin_dir << llendl;
-		xml_search_paths.append(this_skin_dir);
-		++iter;
-		if (iter != xui_path_vec.end())
-			xml_search_paths.append(","); // comma-delimit
+	BOOST_FOREACH(std::string this_skin_path, xui_path_vec)
+	{
+		// Although we already have the full set of paths with the filename
+		// appended, the linux-updater.bin command-line switches require us to
+		// snip the filename OFF and pass it as a separate switch argument. :-P
+		llinfos << "Got a XUI path: " << this_skin_path << llendl;
+		xml_search_paths.append(delim);
+		xml_search_paths.append(gDirUtilp->getDirName(this_skin_path));
+		delim = ",";
 	}
 	// build the overall command-line to run the updater correctly
 	LLAppViewer::sUpdaterInfo->mUpdateExePath = 
diff --git a/indra/newview/lldaycyclemanager.cpp b/indra/newview/lldaycyclemanager.cpp
index 347a467a8b..8af2f4ea33 100644
--- a/indra/newview/lldaycyclemanager.cpp
+++ b/indra/newview/lldaycyclemanager.cpp
@@ -184,7 +184,7 @@ void LLDayCycleManager::loadPresets(const std::string& dir)
 	{
 		std::string file;
 		if (!dir_iter.next(file)) break; // no more files
-		loadPreset(dir + file);
+		loadPreset(gDirUtilp->add(dir, file));
 	}
 }
 
diff --git a/indra/newview/llfloateruipreview.cpp b/indra/newview/llfloateruipreview.cpp
index d741b5b133..15e0b89f6c 100644
--- a/indra/newview/llfloateruipreview.cpp
+++ b/indra/newview/llfloateruipreview.cpp
@@ -137,7 +137,7 @@ public:
 	virtual ~LLFloaterUIPreview();
 
 	std::string getLocStr(S32 ID);							// fetches the localization string based on what is selected in the drop-down menu
-	void displayFloater(BOOL click, S32 ID, bool save = false);			// needs to be public so live file can call it when it finds an update
+	void displayFloater(BOOL click, S32 ID);			// needs to be public so live file can call it when it finds an update
 
 	/*virtual*/ BOOL postBuild();
 	/*virtual*/ void onClose(bool app_quitting);
@@ -291,7 +291,8 @@ LLLocalizationResetForcer::LLLocalizationResetForcer(LLFloaterUIPreview* floater
 {
 	mSavedLocalization = LLUI::sSettingGroups["config"]->getString("Language");				// save current localization setting
 	LLUI::sSettingGroups["config"]->setString("Language", floater->getLocStr(ID));// hack language to be the one we want to preview floaters in
-	LLUI::setupPaths();														// forcibly reset XUI paths with this new language
+	// forcibly reset XUI paths with this new language
+	gDirUtilp->setSkinFolder(gDirUtilp->getSkinFolder(), floater->getLocStr(ID));
 }
 
 // Actually reset in destructor
@@ -299,7 +300,8 @@ LLLocalizationResetForcer::LLLocalizationResetForcer(LLFloaterUIPreview* floater
 LLLocalizationResetForcer::~LLLocalizationResetForcer()
 {
 	LLUI::sSettingGroups["config"]->setString("Language", mSavedLocalization);	// reset language to what it was before we changed it
-	LLUI::setupPaths();														// forcibly reset XUI paths with this new language
+	// forcibly reset XUI paths with this new language
+	gDirUtilp->setSkinFolder(gDirUtilp->getSkinFolder(), mSavedLocalization);
 }
 
 // Live file constructor
@@ -488,7 +490,7 @@ BOOL LLFloaterUIPreview::postBuild()
 	{
 		if((found = iter.next(language_directory)))							// get next directory
 		{
-			std::string full_path = xui_dir + language_directory;
+			std::string full_path = gDirUtilp->add(xui_dir, language_directory);
 			if(LLFile::isfile(full_path.c_str()))																	// if it's not a directory, skip it
 			{
 				continue;
@@ -773,7 +775,8 @@ void LLFloaterUIPreview::onClickDisplayFloater(S32 caller_id)
 // Saves the current floater/panel
 void LLFloaterUIPreview::onClickSaveFloater(S32 caller_id)
 {
-	displayFloater(TRUE, caller_id, true);
+	displayFloater(TRUE, caller_id);
+	popupAndPrintWarning("Save-floater functionality removed, use XML schema to clean up XUI files");
 }
 
 // Saves all floater/panels
@@ -784,25 +787,15 @@ void LLFloaterUIPreview::onClickSaveAll(S32 caller_id)
 	for (int index = 0; index < listSize; index++)
 	{
 		mFileList->selectNthItem(index);
-		displayFloater(TRUE, caller_id, true);
+		displayFloater(TRUE, caller_id);
 	}
-}
-
-// Given path to floater or panel XML file "filename.xml",
-// returns "filename_new.xml"
-static std::string append_new_to_xml_filename(const std::string& path)
-{
-	std::string full_filename = gDirUtilp->findSkinnedFilename(LLUI::getLocalizedSkinPath(), path);
-	std::string::size_type extension_pos = full_filename.rfind(".xml");
-	full_filename.resize(extension_pos);
-	full_filename += "_new.xml";
-	return full_filename;
+	popupAndPrintWarning("Save-floater functionality removed, use XML schema to clean up XUI files");
 }
 
 // Actually display the floater
 // Only set up a new live file if this came from a click (at which point there should be no existing live file), rather than from the live file's update itself;
 // otherwise, we get an infinite loop as the live file keeps recreating itself.  That means this function is generally called twice.
-void LLFloaterUIPreview::displayFloater(BOOL click, S32 ID, bool save)
+void LLFloaterUIPreview::displayFloater(BOOL click, S32 ID)
 {
 	// Convince UI that we're in a different language (the one selected on the drop-down menu)
 	LLLocalizationResetForcer reset_forcer(this, ID);						// save old language in reset forcer object (to be reset upon destruction when it falls out of scope)
@@ -843,48 +836,13 @@ void LLFloaterUIPreview::displayFloater(BOOL click, S32 ID, bool save)
 	if(!strncmp(path.c_str(),"floater_",8)
 		|| !strncmp(path.c_str(), "inspect_", 8))		// if it's a floater
 	{
-		if (save)
-		{
-			LLXMLNodePtr floater_write = new LLXMLNode();			
-			(*floaterp)->buildFromFile(path, floater_write);	// just build it
-
-			if (!floater_write->isNull())
-			{
-				std::string full_filename = append_new_to_xml_filename(path);
-				LLFILE* floater_temp = LLFile::fopen(full_filename.c_str(), "w");
-				LLXMLNode::writeHeaderToFile(floater_temp);
-				const bool use_type_decorations = false;
-				floater_write->writeToFile(floater_temp, std::string(), use_type_decorations);
-				fclose(floater_temp);
-			}
-		}
-		else
-		{
-			(*floaterp)->buildFromFile(path);	// just build it
-			(*floaterp)->openFloater((*floaterp)->getKey());
-			(*floaterp)->setCanResize((*floaterp)->isResizable());
-		}
-
+		(*floaterp)->buildFromFile(path);	// just build it
+		(*floaterp)->openFloater((*floaterp)->getKey());
+		(*floaterp)->setCanResize((*floaterp)->isResizable());
 	}
 	else if (!strncmp(path.c_str(),"menu_",5))								// if it's a menu
 	{
-		if (save)
-		{	
-			LLXMLNodePtr menu_write = new LLXMLNode();	
-			LLMenuGL* menu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>(path, gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance(), menu_write);
-
-			if (!menu_write->isNull())
-			{
-				std::string full_filename = append_new_to_xml_filename(path);
-				LLFILE* menu_temp = LLFile::fopen(full_filename.c_str(), "w");
-				LLXMLNode::writeHeaderToFile(menu_temp);
-				const bool use_type_decorations = false;
-				menu_write->writeToFile(menu_temp, std::string(), use_type_decorations);
-				fclose(menu_temp);
-			}
-
-			delete menu;
-		}
+		// former 'save' processing excised
 	}
 	else																// if it is a panel...
 	{
@@ -896,39 +854,21 @@ void LLFloaterUIPreview::displayFloater(BOOL click, S32 ID, bool save)
 		LLPanel::Params panel_params;
 		LLPanel* panel = LLUICtrlFactory::create<LLPanel>(panel_params);	// create a new panel
 
-		if (save)
-		{
-			LLXMLNodePtr panel_write = new LLXMLNode();
-			panel->buildFromFile(path, panel_write);		// build it
-			
-			if (!panel_write->isNull())
-			{
-				std::string full_filename = append_new_to_xml_filename(path);
-				LLFILE* panel_temp = LLFile::fopen(full_filename.c_str(), "w");
-				LLXMLNode::writeHeaderToFile(panel_temp);
-				const bool use_type_decorations = false;
-				panel_write->writeToFile(panel_temp, std::string(), use_type_decorations);
-				fclose(panel_temp);
-			}
-		}
-		else
-		{
-			panel->buildFromFile(path);										// build it
-			LLRect new_size = panel->getRect();								// get its rectangle
-			panel->setOrigin(2,2);											// reset its origin point so it's not offset by -left or other XUI attributes
-			(*floaterp)->setTitle(path);									// use the file name as its title, since panels have no guaranteed meaningful name attribute
-			panel->setUseBoundingRect(TRUE);								// enable the use of its outer bounding rect (normally disabled because it's O(n) on the number of sub-elements)
-			panel->updateBoundingRect();									// update bounding rect
-			LLRect bounding_rect = panel->getBoundingRect();				// get the bounding rect
-			LLRect new_rect = panel->getRect();								// get the panel's rect
-			new_rect.unionWith(bounding_rect);								// union them to make sure we get the biggest one possible
-			LLRect floater_rect = new_rect;
-			floater_rect.stretch(4, 4);
-			(*floaterp)->reshape(floater_rect.getWidth(), floater_rect.getHeight() + floater_header_size);	// reshape floater to match the union rect's dimensions
-			panel->reshape(new_rect.getWidth(), new_rect.getHeight());		// reshape panel to match the union rect's dimensions as well (both are needed)
-			(*floaterp)->addChild(panel);					// add panel as child
-			(*floaterp)->openFloater();						// open floater (needed?)
-		}
+		panel->buildFromFile(path);										// build it
+		LLRect new_size = panel->getRect();								// get its rectangle
+		panel->setOrigin(2,2);											// reset its origin point so it's not offset by -left or other XUI attributes
+		(*floaterp)->setTitle(path);									// use the file name as its title, since panels have no guaranteed meaningful name attribute
+		panel->setUseBoundingRect(TRUE);								// enable the use of its outer bounding rect (normally disabled because it's O(n) on the number of sub-elements)
+		panel->updateBoundingRect();									// update bounding rect
+		LLRect bounding_rect = panel->getBoundingRect();				// get the bounding rect
+		LLRect new_rect = panel->getRect();								// get the panel's rect
+		new_rect.unionWith(bounding_rect);								// union them to make sure we get the biggest one possible
+		LLRect floater_rect = new_rect;
+		floater_rect.stretch(4, 4);
+		(*floaterp)->reshape(floater_rect.getWidth(), floater_rect.getHeight() + floater_header_size);	// reshape floater to match the union rect's dimensions
+		panel->reshape(new_rect.getWidth(), new_rect.getHeight());		// reshape panel to match the union rect's dimensions as well (both are needed)
+		(*floaterp)->addChild(panel);					// add panel as child
+		(*floaterp)->openFloater();						// open floater (needed?)
 	}
 
 	if(ID == 1)
@@ -964,7 +904,7 @@ void LLFloaterUIPreview::displayFloater(BOOL click, S32 ID, bool save)
 	(*floaterp)->center();
 	addDependentFloater(*floaterp);
 
-	if(click && ID == 1 && !save)
+	if(click && ID == 1)
 	{
 		// set up live file to track it
 		if(mLiveFile)
diff --git a/indra/newview/llhints.cpp b/indra/newview/llhints.cpp
index e15862e2a4..197408b40e 100644
--- a/indra/newview/llhints.cpp
+++ b/indra/newview/llhints.cpp
@@ -171,12 +171,12 @@ LLHintPopup::LLHintPopup(const LLHintPopup::Params& p)
 	}
 	if (p.hint_image.isProvided())
 	{
-		buildFromFile("panel_hint_image.xml", NULL, p);
+		buildFromFile("panel_hint_image.xml", p);
 		getChild<LLIconCtrl>("hint_image")->setImage(p.hint_image());
 	}
 	else
 	{
-		buildFromFile( "panel_hint.xml", NULL, p);
+		buildFromFile( "panel_hint.xml", p);
 	}
 }
 
diff --git a/indra/newview/llmediactrl.cpp b/indra/newview/llmediactrl.cpp
index 7650fe9229..99b4707158 100644
--- a/indra/newview/llmediactrl.cpp
+++ b/indra/newview/llmediactrl.cpp
@@ -564,32 +564,13 @@ void LLMediaCtrl::navigateTo( std::string url_in, std::string mime_type)
 //
 void LLMediaCtrl::navigateToLocalPage( const std::string& subdir, const std::string& filename_in )
 {
-	std::string language = LLUI::getLanguage();
-	std::string delim = gDirUtilp->getDirDelimiter();
-	std::string filename;
+	std::string filename(gDirUtilp->add(subdir, filename_in));
+	std::string expanded_filename = gDirUtilp->findSkinnedFilename("html", filename);
 
-	filename += subdir;
-	filename += delim;
-	filename += filename_in;
-
-	std::string expanded_filename = gDirUtilp->findSkinnedFilename("html", language, filename);
-
-	if (! gDirUtilp->fileExists(expanded_filename))
+	if (expanded_filename.empty())
 	{
-		if (language != "en")
-		{
-			expanded_filename = gDirUtilp->findSkinnedFilename("html", "en", filename);
-			if (! gDirUtilp->fileExists(expanded_filename))
-			{
-				llwarns << "File " << subdir << delim << filename_in << "not found" << llendl;
-				return;
-			}
-		}
-		else
-		{
-			llwarns << "File " << subdir << delim << filename_in << "not found" << llendl;
-			return;
-		}
+		llwarns << "File " << filename << "not found" << llendl;
+		return;
 	}
 	if (ensureMediaSourceExists())
 	{
@@ -597,7 +578,6 @@ void LLMediaCtrl::navigateToLocalPage( const std::string& subdir, const std::str
 		mMediaSource->setSize(mTextureWidth, mTextureHeight);
 		mMediaSource->navigateTo(expanded_filename, "text/html", false);
 	}
-
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/indra/newview/llpreviewscript.cpp b/indra/newview/llpreviewscript.cpp
index 88727bf59b..9c25e69db0 100644
--- a/indra/newview/llpreviewscript.cpp
+++ b/indra/newview/llpreviewscript.cpp
@@ -815,7 +815,7 @@ void LLScriptEdCore::onBtnDynamicHelp()
 	if (!live_help_floater)
 	{
 		live_help_floater = new LLFloater(LLSD());
-		live_help_floater->buildFromFile("floater_lsl_guide.xml", NULL);
+		live_help_floater->buildFromFile("floater_lsl_guide.xml");
 		LLFloater* parent = dynamic_cast<LLFloater*>(getParent());
 		llassert(parent);
 		if (parent)
diff --git a/indra/newview/llsyswellwindow.cpp b/indra/newview/llsyswellwindow.cpp
index 0cb6c85012..2002647fef 100644
--- a/indra/newview/llsyswellwindow.cpp
+++ b/indra/newview/llsyswellwindow.cpp
@@ -242,7 +242,7 @@ LLIMWellWindow::RowPanel::RowPanel(const LLSysWellWindow* parent, const LLUUID&
 		S32 chicletCounter, const std::string& name, const LLUUID& otherParticipantId) :
 		LLPanel(LLPanel::Params()), mChiclet(NULL), mParent(parent)
 {
-	buildFromFile( "panel_activeim_row.xml", NULL);
+	buildFromFile( "panel_activeim_row.xml");
 
 	// Choose which of the pre-created chiclets (IM/group) to use.
 	// The other one gets hidden.
@@ -356,7 +356,7 @@ LLIMWellWindow::ObjectRowPanel::ObjectRowPanel(const LLUUID& notification_id, bo
  : LLPanel()
  , mChiclet(NULL)
 {
-	buildFromFile( "panel_active_object_row.xml", NULL);
+	buildFromFile( "panel_active_object_row.xml");
 
 	initChiclet(notification_id);
 
diff --git a/indra/newview/lltoast.cpp b/indra/newview/lltoast.cpp
index 0eec7f0afd..9dfb29b905 100644
--- a/indra/newview/lltoast.cpp
+++ b/indra/newview/lltoast.cpp
@@ -118,7 +118,7 @@ LLToast::LLToast(const LLToast::Params& p)
 {
 	mTimer.reset(new LLToastLifeTimer(this, p.lifetime_secs));
 
-	buildFromFile("panel_toast.xml", NULL);
+	buildFromFile("panel_toast.xml");
 
 	setCanDrag(FALSE);
 
diff --git a/indra/newview/llviewermedia.cpp b/indra/newview/llviewermedia.cpp
index 1eb4bedfaf..47059b0b8c 100644
--- a/indra/newview/llviewermedia.cpp
+++ b/indra/newview/llviewermedia.cpp
@@ -1184,12 +1184,9 @@ void LLViewerMedia::clearAllCookies()
 	LLDirIterator dir_iter(base_dir, "*_*");
 	while (dir_iter.next(filename))
 	{
-		target = base_dir;
-		target += filename;
-		target += gDirUtilp->getDirDelimiter();
-		target += "browser_profile";
-		target += gDirUtilp->getDirDelimiter();
-		target += "cookies";
+		target = gDirUtilp->add(base_dir, filename);
+		gDirUtilp->append(target, "browser_profile");
+		gDirUtilp->append(target, "cookies");
 		lldebugs << "target = " << target << llendl;
 		if(LLFile::isfile(target))
 		{	
@@ -1197,10 +1194,8 @@ void LLViewerMedia::clearAllCookies()
 		}
 		
 		// Other accounts may have new-style cookie files too -- delete them as well
-		target = base_dir;
-		target += filename;
-		target += gDirUtilp->getDirDelimiter();
-		target += PLUGIN_COOKIE_FILE_NAME;
+		target = gDirUtilp->add(base_dir, filename);
+		gDirUtilp->append(target, PLUGIN_COOKIE_FILE_NAME);
 		lldebugs << "target = " << target << llendl;
 		if(LLFile::isfile(target))
 		{	
diff --git a/indra/newview/llviewertexturelist.cpp b/indra/newview/llviewertexturelist.cpp
index 9a6c0569a9..7eb1a202a0 100644
--- a/indra/newview/llviewertexturelist.cpp
+++ b/indra/newview/llviewertexturelist.cpp
@@ -1583,49 +1583,42 @@ struct UIImageDeclarations : public LLInitParam::Block<UIImageDeclarations>
 
 bool LLUIImageList::initFromFile()
 {
-	// construct path to canonical textures.xml in default skin dir
-	std::string base_file_path = gDirUtilp->getExpandedFilename(LL_PATH_SKINS, "default", "textures", "textures.xml");
+	// Look for textures.xml in all the right places. Pass merge=true because
+	// we want to overlay textures.xml from all the skins directories.
+	std::vector<std::string> textures_paths =
+		gDirUtilp->findSkinnedFilenames(LLDir::TEXTURES, "textures.xml", true);
+	std::vector<std::string>::const_iterator pi(textures_paths.begin()), pend(textures_paths.end());
+	if (pi == pend)
+	{
+		llwarns << "No textures.xml found in skins directories" << llendl;
+		return false;
+	}
 
+	// The first (most generic) file gets special validations
 	LLXMLNodePtr root;
-
-	if (!LLXMLNode::parseFile(base_file_path, root, NULL))
+	if (!LLXMLNode::parseFile(*pi, root, NULL))
 	{
-		llwarns << "Unable to parse UI image list file " << base_file_path << llendl;
+		llwarns << "Unable to parse UI image list file " << *pi << llendl;
 		return false;
 	}
 	if (!root->hasAttribute("version"))
 	{
-		llwarns << "No valid version number in UI image list file " << base_file_path << llendl;
+		llwarns << "No valid version number in UI image list file " << *pi << llendl;
 		return false;
 	}
 
 	UIImageDeclarations images;
 	LLXUIParser parser;
-	parser.readXUI(root, images, base_file_path);
-
-	// add components defined in current skin
-	std::string skin_update_path = gDirUtilp->getSkinDir() 
-									+ gDirUtilp->getDirDelimiter() 
-									+ "textures"
-									+ gDirUtilp->getDirDelimiter()
-									+ "textures.xml";
-	LLXMLNodePtr update_root;
-	if (skin_update_path != base_file_path
-		&& LLXMLNode::parseFile(skin_update_path, update_root, NULL))
-	{
-		parser.readXUI(update_root, images, skin_update_path);
-	}
-
-	// add components defined in user override of current skin
-	skin_update_path = gDirUtilp->getUserSkinDir() 
-						+ gDirUtilp->getDirDelimiter() 
-						+ "textures"
-						+ gDirUtilp->getDirDelimiter()
-						+ "textures.xml";
-	if (skin_update_path != base_file_path
-		&& LLXMLNode::parseFile(skin_update_path, update_root, NULL))
-	{
-		parser.readXUI(update_root, images, skin_update_path);
+	parser.readXUI(root, images, *pi);
+
+	// add components defined in the rest of the skin paths
+	while (++pi != pend)
+	{
+		LLXMLNodePtr update_root;
+		if (LLXMLNode::parseFile(*pi, update_root, NULL))
+		{
+			parser.readXUI(update_root, images, *pi);
+		}
 	}
 
 	if (!images.validateBlock()) return false;
diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp
index 30bb787fa7..e569c9504f 100644
--- a/indra/newview/llviewerwindow.cpp
+++ b/indra/newview/llviewerwindow.cpp
@@ -1685,8 +1685,7 @@ LLViewerWindow::LLViewerWindow(const Params& p)
 	LLFontGL::initClass( gSavedSettings.getF32("FontScreenDPI"),
 								mDisplayScale.mV[VX],
 								mDisplayScale.mV[VY],
-								gDirUtilp->getAppRODataDir(),
-								LLUI::getXUIPaths());
+								gDirUtilp->getAppRODataDir());
 	
 	// Create container for all sub-views
 	LLView::Params rvp;
@@ -4757,8 +4756,7 @@ void LLViewerWindow::initFonts(F32 zoom_factor)
 	LLFontGL::initClass( gSavedSettings.getF32("FontScreenDPI"),
 								mDisplayScale.mV[VX] * zoom_factor,
 								mDisplayScale.mV[VY] * zoom_factor,
-								gDirUtilp->getAppRODataDir(),
-								LLUI::getXUIPaths());
+								gDirUtilp->getAppRODataDir());
 	// Force font reloads, which can be very slow
 	LLFontGL::loadDefaultFonts();
 }
diff --git a/indra/newview/llwaterparammanager.cpp b/indra/newview/llwaterparammanager.cpp
index e386112334..4f52ff9778 100644
--- a/indra/newview/llwaterparammanager.cpp
+++ b/indra/newview/llwaterparammanager.cpp
@@ -100,7 +100,7 @@ void LLWaterParamManager::loadPresetsFromDir(const std::string& dir)
 			break; // no more files
 		}
 
-		std::string path = dir + file;
+		std::string path = gDirUtilp->add(dir, file);
 		if (!loadPreset(path))
 		{
 			llwarns << "Error loading water preset from " << path << llendl;
diff --git a/indra/newview/llwlparammanager.cpp b/indra/newview/llwlparammanager.cpp
index 49d9d44d74..6077208799 100644
--- a/indra/newview/llwlparammanager.cpp
+++ b/indra/newview/llwlparammanager.cpp
@@ -283,7 +283,7 @@ void LLWLParamManager::loadPresetsFromDir(const std::string& dir)
 			break; // no more files
 		}
 
-		std::string path = dir + file;
+		std::string path = gDirUtilp->add(dir, file);
 		if (!loadPreset(path))
 		{
 			llwarns << "Error loading sky preset from " << path << llendl;
diff --git a/indra/newview/skins/paths.xml b/indra/newview/skins/paths.xml
deleted file mode 100644
index 3c0da041c7..0000000000
--- a/indra/newview/skins/paths.xml
+++ /dev/null
@@ -1,10 +0,0 @@
-<paths> 
-	<directory>
-    <subdir>xui</subdir>
-    <subdir>en</subdir>
-  </directory>
-	<directory>
-    <subdir>xui</subdir>
-    <subdir>[LANGUAGE]</subdir>
-  </directory>
-</paths>
\ No newline at end of file
diff --git a/indra/newview/tests/lldir_stub.cpp b/indra/newview/tests/lldir_stub.cpp
index 18cf4e7419..3c0a4377d8 100644
--- a/indra/newview/tests/lldir_stub.cpp
+++ b/indra/newview/tests/lldir_stub.cpp
@@ -32,7 +32,7 @@ BOOL LLDir::deleteFilesInDir(const std::string &dirname, const std::string &mask
 void LLDir::setChatLogsDir(const std::string &path) {}
 void LLDir::setPerAccountChatLogsDir(const std::string &first, const std::string &last) {}
 void LLDir::setLindenUserDir(const std::string &first, const std::string &last) {}
-void LLDir::setSkinFolder(const std::string &skin_folder) {}
+void LLDir::setSkinFolder(const std::string &skin_folder, const std::string& language) {}
 bool LLDir::setCacheDir(const std::string &path) { return true; }
 void LLDir::dumpCurrentDirectories() {}
 
diff --git a/indra/newview/viewer_manifest.py b/indra/newview/viewer_manifest.py
index 7c6b5403e1..e754c26733 100644
--- a/indra/newview/viewer_manifest.py
+++ b/indra/newview/viewer_manifest.py
@@ -114,7 +114,6 @@ class ViewerManifest(LLManifest):
 
             # skins
             if self.prefix(src="skins"):
-                    self.path("paths.xml")
                     # include the entire textures directory recursively
                     if self.prefix(src="*/textures"):
                             self.path("*/*.tga")
diff --git a/indra/viewer_components/updater/tests/llupdaterservice_test.cpp b/indra/viewer_components/updater/tests/llupdaterservice_test.cpp
index 7c016fecf9..db52e6c55f 100644
--- a/indra/viewer_components/updater/tests/llupdaterservice_test.cpp
+++ b/indra/viewer_components/updater/tests/llupdaterservice_test.cpp
@@ -78,7 +78,9 @@ S32 LLDir::deleteFilesInDir(const std::string &dirname,
 void LLDir::setChatLogsDir(const std::string &path){}		
 void LLDir::setPerAccountChatLogsDir(const std::string &username){}
 void LLDir::setLindenUserDir(const std::string &username){}		
-void LLDir::setSkinFolder(const std::string &skin_folder){}
+void LLDir::setSkinFolder(const std::string &skin_folder, const std::string& language){}
+std::string LLDir::getSkinFolder() const { return "default"; }
+std::string LLDir::getLanguage() const { return "en"; }
 bool LLDir::setCacheDir(const std::string &path){ return true; }
 void LLDir::dumpCurrentDirectories() {}
 
-- 
cgit v1.3


From c5373b90eb2de8f29be6801a07e937064ecb7fbb Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 15 Oct 2012 16:16:24 -0400
Subject: Add 'sourceid' settings var specifically for skin-files insertion.
 Add logic after (both!) LLTransUtil::parseStrings() calls to ensure that
 "[sourceid]" embedded in (e.g.) strings.xml content will be replaced.

---
 indra/newview/app_settings/settings.xml | 11 +++++++++++
 indra/newview/llappviewer.cpp           |  4 ++++
 2 files changed, 15 insertions(+)

(limited to 'indra/newview/llappviewer.cpp')

diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml
index 5e50bd6e01..89f300548e 100644
--- a/indra/newview/app_settings/settings.xml
+++ b/indra/newview/app_settings/settings.xml
@@ -12285,6 +12285,17 @@
       <key>Value</key>
       <integer>0</integer>
     </map>
+    <key>sourceid</key>
+    <map>
+      <key>Comment</key>
+      <string>Identify referring agency to Linden web servers</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>String</string>
+      <key>Value</key>
+      <string />
+    </map>
     <key>SpeakerParticipantDefaultOrder</key>
     <map>
       <key>Comment</key>
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index efa24796e5..9637bd328e 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -771,6 +771,8 @@ bool LLAppViewer::init()
 	LLUI::setupPaths();
 	LLTransUtil::parseStrings("strings.xml", default_trans_args);
 	LLTransUtil::parseLanguageStrings("language_settings.xml");
+	// parseStrings() sets up the LLTrans substitution table. Add this one item.
+	LLTrans::setDefaultArg("[sourceid]", gSavedSettings.getString("sourceid"));
 
 	// Setup notifications after LLUI::setupPaths() has been called.
 	LLNotifications::instance();
@@ -2242,6 +2244,8 @@ bool LLAppViewer::initConfiguration()
 	LLUI::setupPaths(); // setup paths for LLTrans based on settings files only
 	LLTransUtil::parseStrings("strings.xml", default_trans_args);
 	LLTransUtil::parseLanguageStrings("language_settings.xml");
+	// parseStrings() sets up the LLTrans substitution table. Add this one item.
+	LLTrans::setDefaultArg("[sourceid]", gSavedSettings.getString("sourceid"));
 	// - set procedural settings
 	// Note: can't use LL_PATH_PER_SL_ACCOUNT for any of these since we haven't logged in yet
 	gSavedSettings.setString("ClientSettingsFile", 
-- 
cgit v1.3


From 988767d5ec4631ad9f0099180a92c4f186553940 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 16 Oct 2012 09:56:45 -0400
Subject: Introduce LLAppViewer::initStrings(); reload default_trans_args.
 Calling LLTrans::setDefaultArg() after LLTransUtil::parseStrings() is almost
 good enough -- but it fails to address the case in which one or more of the
 default_trans_args strings (e.g. "create_account_url") embeds a reference to
 the new substitution. So after the setDefaultArg() call, go back through
 default_trans_args, refetching each string to perform the substitution and
 updating it with a setDefaultArg() call of its own. All this is way too much
 logic to replicate in both LLAppViewer::initConfiguration() and init(), so
 break out new LLAppViewer::initStrings() method and call it from both places.

---
 indra/newview/llappviewer.cpp | 62 +++++++++++++++++++++++++++++++++++--------
 indra/newview/llappviewer.h   |  1 +
 2 files changed, 52 insertions(+), 11 deletions(-)

(limited to 'indra/newview/llappviewer.cpp')

diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 9637bd328e..0c4c8a66e5 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -114,6 +114,7 @@
 #include "llnotificationsutil.h"
 
 #include "llleap.h"
+#include "stringize.h"
 
 // Third party library includes
 #include <boost/bind.hpp>
@@ -768,11 +769,7 @@ bool LLAppViewer::init()
 	LL_INFOS("InitInfo") << "UI initialized." << LL_ENDL ;
 
 	// Setup paths and LLTrans after LLUI::initClass has been called.
-	LLUI::setupPaths();
-	LLTransUtil::parseStrings("strings.xml", default_trans_args);
-	LLTransUtil::parseLanguageStrings("language_settings.xml");
-	// parseStrings() sets up the LLTrans substitution table. Add this one item.
-	LLTrans::setDefaultArg("[sourceid]", gSavedSettings.getString("sourceid"));
+	initStrings();
 
 	// Setup notifications after LLUI::setupPaths() has been called.
 	LLNotifications::instance();
@@ -2240,12 +2237,8 @@ bool LLAppViewer::initConfiguration()
 		OSMessageBox(msg.str(),LLStringUtil::null,OSMB_OK);
 		return false;
 	}
-	
-	LLUI::setupPaths(); // setup paths for LLTrans based on settings files only
-	LLTransUtil::parseStrings("strings.xml", default_trans_args);
-	LLTransUtil::parseLanguageStrings("language_settings.xml");
-	// parseStrings() sets up the LLTrans substitution table. Add this one item.
-	LLTrans::setDefaultArg("[sourceid]", gSavedSettings.getString("sourceid"));
+
+	initStrings(); // setup paths for LLTrans based on settings files only
 	// - set procedural settings
 	// Note: can't use LL_PATH_PER_SL_ACCOUNT for any of these since we haven't logged in yet
 	gSavedSettings.setString("ClientSettingsFile", 
@@ -2730,6 +2723,53 @@ bool LLAppViewer::initConfiguration()
 	return true; // Config was successful.
 }
 
+// The following logic is replicated in initConfiguration() (to be able to get
+// some initial strings before we've finished initializing enough to know the
+// current language) and also in init() (to initialize for real). Somehow it
+// keeps growing, necessitating a method all its own.
+void LLAppViewer::initStrings()
+{
+	LLUI::setupPaths();
+	LLTransUtil::parseStrings("strings.xml", default_trans_args);
+	LLTransUtil::parseLanguageStrings("language_settings.xml");
+
+	// parseStrings() sets up the LLTrans substitution table. Add this one item.
+	LLTrans::setDefaultArg("[sourceid]", gSavedSettings.getString("sourceid"));
+
+	// Now that we've set "[sourceid]", have to go back through
+	// default_trans_args and reinitialize all those other keys because some
+	// of them, in turn, reference "[sourceid]".
+	BOOST_FOREACH(std::string key, default_trans_args)
+	{
+		std::string brackets(key), nobrackets(key);
+		// Invalid to inspect key[0] if key is empty(). But then, the entire
+		// body of this loop is pointless if key is empty().
+		if (key.empty())
+			continue;
+
+		if (key[0] != '[')
+		{
+			// key was passed without brackets. That means that 'nobrackets'
+			// is correct but 'brackets' is not.
+			brackets = STRINGIZE('[' << brackets << ']');
+		}
+		else
+		{
+			// key was passed with brackets. That means that 'brackets' is
+			// correct but 'nobrackets' is not. Erase the left bracket.
+			nobrackets.erase(0, 1);
+			std::string::size_type length(nobrackets.length());
+			if (length && nobrackets[length - 1] == ']')
+			{
+				nobrackets.erase(length - 1);
+			}
+		}
+		// Calling LLTrans::getString() is what embeds the other default
+		// translation strings into this one.
+		LLTrans::setDefaultArg(brackets, LLTrans::getString(nobrackets));
+	}
+}
+
 namespace {
     // *TODO - decide if there's a better place for these functions.
 	// do we need a file llupdaterui.cpp or something? -brad
diff --git a/indra/newview/llappviewer.h b/indra/newview/llappviewer.h
index ae3c795d1e..5a3a41690a 100644
--- a/indra/newview/llappviewer.h
+++ b/indra/newview/llappviewer.h
@@ -194,6 +194,7 @@ private:
 	void initMaxHeapSize();
 	bool initThreads(); // Initialize viewer threads, return false on failure.
 	bool initConfiguration(); // Initialize settings from the command line/config file.
+	void initStrings();       // Initialize LLTrans machinery
 	void initUpdater(); // Initialize the updater service.
 	bool initCache(); // Initialize local client cache.
 	void checkMemory() ;
-- 
cgit v1.3


From b344612e4c99ea57b98e88d5569f50fed1dd8955 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 14 Nov 2012 16:00:02 -0500
Subject: DRTVWR-241: resolve merge conflict with viewer-development.
 LLUI::setupPaths() went away with DRTVWR-210.

---
 indra/newview/llappviewer.cpp | 1 -
 1 file changed, 1 deletion(-)

(limited to 'indra/newview/llappviewer.cpp')

diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index fddf8bd7a3..438194c715 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -2765,7 +2765,6 @@ bool LLAppViewer::initConfiguration()
 // keeps growing, necessitating a method all its own.
 void LLAppViewer::initStrings()
 {
-	LLUI::setupPaths();
 	LLTransUtil::parseStrings("strings.xml", default_trans_args);
 	LLTransUtil::parseLanguageStrings("language_settings.xml");
 
-- 
cgit v1.3