svn merge -r95288:95907 svn+ssh://svn.lindenlab.com/svn/linden/qa/maint-server/qar-841

this is a combined mergeback of the following branches as per QAR-841:
  maint-server/maint-server-1 (absorbed by maint-server-2)
  maint-server/maint-server-2
  maint-server/maint-server-3
  havok4/havok4-8
  havok4/havok4-9

yes dataserver-is-deprecated

49 files changed, 1248 insertions, 662 deletions

diff --git a/indra/llcommon/llcommon.cpp b/indra/llcommon/llcommon.cpp
index 0069d03de0..268b12b02a 100644
--- a/indra/llcommon/llcommon.cpp
+++ b/indra/llcommon/llcommon.cpp
@@ -46,7 +46,7 @@ void LLCommon::initClass()
 		sAprInitialized = TRUE;
 	}
 	LLTimer::initClass();
-	LLThreadSafeRefCount::initClass();
+	LLThreadSafeRefCount::initThreadSafeRefCount();
 // 	LLWorkerThread::initClass();
 // 	LLFrameCallbackManager::initClass();
 }
@@ -56,7 +56,7 @@ void LLCommon::cleanupClass()
 {
 // 	LLFrameCallbackManager::cleanupClass();
 // 	LLWorkerThread::cleanupClass();
-	LLThreadSafeRefCount::cleanupClass();
+	LLThreadSafeRefCount::cleanupThreadSafeRefCount();
 	LLTimer::cleanupClass();
 	if (sAprInitialized)
 	{
diff --git a/indra/llcommon/llsdserialize.cpp b/indra/llcommon/llsdserialize.cpp
index e4ad00da6d..d496230dd8 100644
--- a/indra/llcommon/llsdserialize.cpp
+++ b/indra/llcommon/llsdserialize.cpp
@@ -324,7 +324,7 @@ S32 LLSDParser::parse(std::istream& istr, LLSD& data, S32 max_bytes)
 S32 LLSDParser::parseLines(std::istream& istr, LLSD& data)
 {
 	mCheckLimits = false;
-	mParseLines = false;		// was true, Emergency fix DEV-17785 parsing newline failure
+	mParseLines = true;
 	return doParse(istr, data);
 }
 
diff --git a/indra/llcommon/llsdserialize_xml.cpp b/indra/llcommon/llsdserialize_xml.cpp
index 51a2e5ec40..edcc244f58 100644
--- a/indra/llcommon/llsdserialize_xml.cpp
+++ b/indra/llcommon/llsdserialize_xml.cpp
@@ -461,11 +461,11 @@ S32 LLSDXMLParser::Impl::parseLines(std::istream& input, LLSD& data)
 				input.clear();
 			}
 		
-			// Don't parse the NULL at the end which might be added if \n was absorbed by getline()
+			// Re-insert with the \n that was absorbed by getline()
 			char * text = (char *) buffer;
 			if ( text[num_read - 1] == 0)
 			{
-				num_read--;
+				text[num_read - 1] = '\n';
 			}
 		}
 
@@ -808,12 +808,11 @@ void LLSDXMLParser::parsePart(const char *buf, int len)
 // virtual
 S32 LLSDXMLParser::doParse(std::istream& input, LLSD& data) const
 {
-// Remove code - emergency fix DEV-17785 parsing newline failure
-//	if (mParseLines)
-//	{
+	if (mParseLines)
+	{
 		// Use line-based reading (faster code)
-//		return impl.parseLines(input, data);
-//	}
+		return impl.parseLines(input, data);
+	}
 
 	return impl.parse(input, data);
 }
diff --git a/indra/llcommon/llstat.cpp b/indra/llcommon/llstat.cpp
index 21b723de71..80492d2e31 100644
--- a/indra/llcommon/llstat.cpp
+++ b/indra/llcommon/llstat.cpp
@@ -34,47 +34,9 @@
 #include "llframetimer.h"
 #include "timing.h"
 
-class LLStatAccum::impl
-{
-public:
-	static const TimeScale IMPL_NUM_SCALES = (TimeScale)(SCALE_TWO_MINUTE + 1);
-	static U64 sScaleTimes[IMPL_NUM_SCALES];
-
-	BOOL	mUseFrameTimer;
-
-	BOOL	mRunning;
-	U64		mLastTime;
-	
-	struct Bucket
-	{
-		F64		accum;
-		U64		endTime;
-
-		BOOL	lastValid;
-		F64		lastAccum;
-	};
-
-	Bucket	mBuckets[IMPL_NUM_SCALES];
-
-	BOOL 	mLastSampleValid;
-	F64 	mLastSampleValue;
-
-
-	impl(bool useFrameTimer);
-
-	void reset(U64 when);
-
-	void sum(F64 value);
-	void sum(F64 value, U64 when);
-
-	F32 meanValue(TimeScale scale) const;
-
-	U64 getCurrentUsecs() const;
-		// Get current microseconds based on timer type
-};
 
 
-U64 LLStatAccum::impl::sScaleTimes[IMPL_NUM_SCALES] =
+U64 LLStatAccum::sScaleTimes[IMPL_NUM_SCALES] =
 {
 	USEC_PER_SEC / 10,				// 100 millisec
 	USEC_PER_SEC * 1,				// seconds
@@ -89,14 +51,22 @@ U64 LLStatAccum::impl::sScaleTimes[IMPL_NUM_SCALES] =
 };
 
 
-LLStatAccum::impl::impl(bool useFrameTimer)
+
+LLStatAccum::LLStatAccum(bool useFrameTimer)
+	: mUseFrameTimer(useFrameTimer),
+	  mRunning(FALSE),
+	  mLastSampleValue(0.0),
+	  mLastSampleValid(FALSE)
+{
+}
+
+LLStatAccum::~LLStatAccum()
 {
-	mUseFrameTimer = useFrameTimer;
-	mRunning = FALSE;
-	mLastSampleValid = FALSE;
 }
 
-void LLStatAccum::impl::reset(U64 when)
+
+
+void LLStatAccum::reset(U64 when)
 {
 	mRunning = TRUE;
 	mLastTime = when;
@@ -109,12 +79,12 @@ void LLStatAccum::impl::reset(U64 when)
 	}
 }
 
-void LLStatAccum::impl::sum(F64 value)
+void LLStatAccum::sum(F64 value)
 {
 	sum(value, getCurrentUsecs());
 }
 
-void LLStatAccum::impl::sum(F64 value, U64 when)
+void LLStatAccum::sum(F64 value, U64 when)
 {
 	if (!mRunning)
 	{
@@ -131,6 +101,9 @@ void LLStatAccum::impl::sum(F64 value, U64 when)
 		return;
 	}
 
+	// how long is this value for
+	U64 timeSpan = when - mLastTime;
+
 	for (int i = 0; i < IMPL_NUM_SCALES; ++i)
 	{
 		Bucket& bucket = mBuckets[i];
@@ -143,8 +116,6 @@ void LLStatAccum::impl::sum(F64 value, U64 when)
 		{
 			U64 timeScale = sScaleTimes[i];
 
-			U64 timeSpan = when - mLastTime;
-				// how long is this value for
 			U64 timeLeft = when - bucket.endTime;
 				// how much time is left after filling this bucket
 			
@@ -173,7 +144,7 @@ void LLStatAccum::impl::sum(F64 value, U64 when)
 }
 
 
-F32 LLStatAccum::impl::meanValue(TimeScale scale) const
+F32 LLStatAccum::meanValue(TimeScale scale) const
 {
 	if (!mRunning)
 	{
@@ -209,7 +180,7 @@ F32 LLStatAccum::impl::meanValue(TimeScale scale) const
 }
 
 
-U64 LLStatAccum::impl::getCurrentUsecs() const
+U64 LLStatAccum::getCurrentUsecs() const
 {
 	if (mUseFrameTimer)
 	{
@@ -222,24 +193,43 @@ U64 LLStatAccum::impl::getCurrentUsecs() const
 }
 
 
+// ------------------------------------------------------------------------
 
-
-
-LLStatAccum::LLStatAccum(bool useFrameTimer)
-	: m(* new impl(useFrameTimer))
+LLStatRate::LLStatRate(bool use_frame_timer)
+	: LLStatAccum(use_frame_timer)
 {
 }
 
-LLStatAccum::~LLStatAccum()
+void LLStatRate::count(U32 value)
 {
-	delete &m;
+	sum((F64)value * sScaleTimes[SCALE_SECOND]);
 }
 
-F32 LLStatAccum::meanValue(TimeScale scale) const
-{
-	return m.meanValue(scale);
-}
 
+void LLStatRate::mark()
+ { 
+	// Effectively the same as count(1), but sets mLastSampleValue
+	U64 when = getCurrentUsecs();
+
+	if ( mRunning 
+		 && (when > mLastTime) )
+	{	// Set mLastSampleValue to the time from the last mark()
+		F64 duration = ((F64)(when - mLastTime)) / sScaleTimes[SCALE_SECOND];
+		if ( duration > 0.0 )
+		{
+			mLastSampleValue = 1.0 / duration;
+		}
+		else
+		{
+			mLastSampleValue = 0.0;
+		}
+	}
+
+	sum( (F64) sScaleTimes[SCALE_SECOND], when);
+ }
+
+
+// ------------------------------------------------------------------------
 
 
 LLStatMeasure::LLStatMeasure(bool use_frame_timer)
@@ -249,53 +239,58 @@ LLStatMeasure::LLStatMeasure(bool use_frame_timer)
 
 void LLStatMeasure::sample(F64 value)
 {
-	U64 when = m.getCurrentUsecs();
+	U64 when = getCurrentUsecs();
 
-	if (m.mLastSampleValid)
+	if (mLastSampleValid)
 	{
-		F64 avgValue = (value + m.mLastSampleValue) / 2.0;
-		F64 interval = (F64)(when - m.mLastTime);
+		F64 avgValue = (value + mLastSampleValue) / 2.0;
+		F64 interval = (F64)(when - mLastTime);
 
-		m.sum(avgValue * interval, when);
+		sum(avgValue * interval, when);
 	}
 	else
 	{
-		m.reset(when);
+		reset(when);
 	}
 
-	m.mLastSampleValid = TRUE;
-	m.mLastSampleValue = value;
-}
-
-
-LLStatRate::LLStatRate(bool use_frame_timer)
-	: LLStatAccum(use_frame_timer)
-{
+	mLastSampleValid = TRUE;
+	mLastSampleValue = value;
 }
 
-void LLStatRate::count(U32 value)
-{
-	m.sum((F64)value * impl::sScaleTimes[SCALE_SECOND]);
-}
 
+// ------------------------------------------------------------------------
 
 LLStatTime::LLStatTime(bool use_frame_timer)
-	: LLStatAccum(use_frame_timer)
+	: LLStatAccum(use_frame_timer),
+	  mFrameNumber(0),
+	  mTotalTimeInFrame(0)
 {
+	mFrameNumber = LLFrameTimer::getFrameCount();
 }
 
 void LLStatTime::start()
 {
-	m.sum(0.0);
+	// Reset frame accumluation if the frame number has changed
+	U32 frame_number = LLFrameTimer::getFrameCount();
+	if ( frame_number != mFrameNumber)
+	{
+		mFrameNumber = frame_number;
+		mTotalTimeInFrame = 0;
+	}
+
+	sum(0.0);
 }
 
 void LLStatTime::stop()
 {
-	U64 endTime = m.getCurrentUsecs();
-	m.sum((F64)(endTime - m.mLastTime), endTime);
+	U64 end_time = getCurrentUsecs();
+	U64 duration = end_time - mLastTime;
+	sum(F64(duration), end_time);
+	mTotalTimeInFrame += duration;
 }
 
 
+// ------------------------------------------------------------------------
 
 LLTimer LLStat::sTimer;
 LLFrameTimer LLStat::sFrameTimer;
diff --git a/indra/llcommon/llstat.h b/indra/llcommon/llstat.h
index 5fa46fca75..d4dcb3a961 100644
--- a/indra/llcommon/llstat.h
+++ b/indra/llcommon/llstat.h
@@ -67,6 +67,9 @@ public:
 		NUM_SCALES
 	};
 
+	static const TimeScale IMPL_NUM_SCALES = (TimeScale)(SCALE_TWO_MINUTE + 1);
+	static U64 sScaleTimes[IMPL_NUM_SCALES];
+
 	F32 meanValue(TimeScale scale) const;
 		// see the subclasses for the specific meaning of value
 
@@ -74,9 +77,32 @@ public:
 	F32 meanValueOverLastSecond() const	{ return meanValue(SCALE_SECOND); }
 	F32 meanValueOverLastMinute() const	{ return meanValue(SCALE_MINUTE); }
 
-protected:
-	class impl;
-	impl& m;
+	void reset(U64 when);
+
+	void sum(F64 value);
+	void sum(F64 value, U64 when);
+
+	U64 getCurrentUsecs() const;
+		// Get current microseconds based on timer type
+
+	BOOL	mUseFrameTimer;
+
+	BOOL	mRunning;
+	U64		mLastTime;
+	
+	struct Bucket
+	{
+		F64		accum;
+		U64		endTime;
+
+		BOOL	lastValid;
+		F64		lastAccum;
+	};
+
+	Bucket	mBuckets[IMPL_NUM_SCALES];
+
+	BOOL 	mLastSampleValid;
+	F64 	mLastSampleValue;
 };
 
 class LLStatMeasure : public LLStatAccum
@@ -105,7 +131,7 @@ public:
 	void count(U32);
 		// used to note that n items have occured
 	
-	void mark() { count(1); }
+	void mark();
 		// used for counting the rate thorugh a point in the code
 };
 
@@ -119,6 +145,9 @@ class LLStatTime : public LLStatAccum
 public:
 	LLStatTime(bool use_frame_timer = false);
 
+	U32		mFrameNumber;		// Current frame number
+	U64		mTotalTimeInFrame;	// Total time (microseconds) accumulated during the last frame
+
 private:
 	void start();
 	void stop();
diff --git a/indra/llcommon/llstl.h b/indra/llcommon/llstl.h
index 99fc83274b..7b7e73470e 100644
--- a/indra/llcommon/llstl.h
+++ b/indra/llcommon/llstl.h
@@ -79,6 +79,9 @@ struct compare_pointer_contents
 // The general form is:
 //
 //  std::for_each(cont.begin(), cont.end(), DeletePointer());
+//  somemap.clear();
+//
+// Don't forget to clear()!
 
 struct DeletePointer
 {
@@ -95,7 +98,7 @@ struct DeletePointerArray
 	}
 };
 
-// DeletePointer is a simple helper for deleting all pointers in a map.
+// DeletePairedPointer is a simple helper for deleting all pointers in a map.
 // The general form is:
 //
 //  std::for_each(somemap.begin(), somemap.end(), DeletePairedPointer());
diff --git a/indra/llcommon/llthread.cpp b/indra/llcommon/llthread.cpp
index dc0a7a83e4..cc58552099 100644
--- a/indra/llcommon/llthread.cpp
+++ b/indra/llcommon/llthread.cpp
@@ -359,7 +359,7 @@ void LLCondition::broadcast()
 LLMutex* LLThreadSafeRefCount::sMutex = 0;
 
 //static
-void LLThreadSafeRefCount::initClass()
+void LLThreadSafeRefCount::initThreadSafeRefCount()
 {
 	if (!sMutex)
 	{
@@ -368,7 +368,7 @@ void LLThreadSafeRefCount::initClass()
 }
 
 //static
-void LLThreadSafeRefCount::cleanupClass()
+void LLThreadSafeRefCount::cleanupThreadSafeRefCount()
 {
 	delete sMutex;
 	sMutex = NULL;
diff --git a/indra/llcommon/llthread.h b/indra/llcommon/llthread.h
index 7864d93395..a6b2c0be7d 100644
--- a/indra/llcommon/llthread.h
+++ b/indra/llcommon/llthread.h
@@ -191,8 +191,8 @@ void LLThread::unlockData()
 class LLThreadSafeRefCount
 {
 public:
-	static void initClass(); // creates sMutex
-	static void cleanupClass(); // destroys sMutex
+	static void initThreadSafeRefCount(); // creates sMutex
+	static void cleanupThreadSafeRefCount(); // destroys sMutex
 	
 private:
 	static LLMutex* sMutex;
diff --git a/indra/llimage/llimage.cpp b/indra/llimage/llimage.cpp
index ef1467ce50..4f4473a366 100644
--- a/indra/llimage/llimage.cpp
+++ b/indra/llimage/llimage.cpp
@@ -43,6 +43,49 @@
 #include "llimagejpeg.h"
 #include "llimagepng.h"
 #include "llimagedxt.h"
+#include "llimageworker.h"
+
+//---------------------------------------------------------------------------
+// LLImage
+//---------------------------------------------------------------------------
+
+//static
+std::string LLImage::sLastErrorMessage;
+LLMutex* LLImage::sMutex = NULL;
+
+//static
+void LLImage::initClass(LLWorkerThread* workerthread)
+{
+	sMutex = new LLMutex(NULL);
+	if (workerthread)
+	{
+		LLImageWorker::initImageWorker(workerthread);
+	}
+	LLImageJ2C::openDSO();
+}
+
+//static
+void LLImage::cleanupClass()
+{
+	LLImageJ2C::closeDSO();
+	LLImageWorker::cleanupImageWorker();
+	delete sMutex;
+	sMutex = NULL;
+}
+
+//static
+const std::string& LLImage::getLastError()
+{
+	static const std::string noerr("No Error");
+	return sLastErrorMessage.empty() ? noerr : sLastErrorMessage;
+}
+
+//static
+void LLImage::setLastError(const std::string& message)
+{
+	LLMutexLock m(sMutex);
+	sLastErrorMessage = message;
+}
 
 //---------------------------------------------------------------------------
 // LLImageBase
@@ -95,21 +138,8 @@ void LLImageBase::sanityCheck()
 	}
 }
 
-std::string LLImageBase::sLastErrorMessage;
 BOOL LLImageBase::sSizeOverride = FALSE;
 
-BOOL LLImageBase::setLastError(const std::string& message, const std::string& filename) 
-{
-	sLastErrorMessage = message;
-	if (!filename.empty())
-	{
-		sLastErrorMessage += " FILE:";
-		sLastErrorMessage += filename;
-	}
-	llwarns << sLastErrorMessage << llendl;
-	return FALSE;
-}
-
 // virtual
 void LLImageBase::deleteData()
 {
@@ -136,8 +166,6 @@ U8* LLImageBase::allocateData(S32 size)
 		llerrs << "LLImageBase::allocateData: bad size: " << size << llendl;
 	}
 	
-	resetLastError();
-
 	if (!mData || size != mDataSize)
 	{
 		deleteData(); // virtual
@@ -1269,6 +1297,23 @@ LLImageFormatted::~LLImageFormatted()
 
 //----------------------------------------------------------------------------
 
+//virtual
+void LLImageFormatted::resetLastError()
+{
+	LLImage::setLastError("");
+}
+
+//virtual
+void LLImageFormatted::setLastError(const std::string& message, const std::string& filename)
+{
+	std::string error = message;
+	if (!filename.empty())
+		error += std::string(" FILE: ") + filename;
+	LLImage::setLastError(error);
+}
+
+//----------------------------------------------------------------------------
+
 // static
 LLImageFormatted* LLImageFormatted::createFromType(S8 codec)
 {
diff --git a/indra/llimage/llimage.h b/indra/llimage/llimage.h
index 8db6a6c5bd..fbff9eae64 100644
--- a/indra/llimage/llimage.h
+++ b/indra/llimage/llimage.h
@@ -59,6 +59,7 @@ const S32 MAX_IMG_PACKET_SIZE = 1000;
 class LLImageFormatted;
 class LLImageRaw;
 class LLColor4U;
+class LLWorkerThread;
 
 typedef enum e_image_codec
 {
@@ -74,6 +75,24 @@ typedef enum e_image_codec
 } EImageCodec;
 
 //============================================================================
+// library initialization class
+
+class LLImage
+{
+public:
+	static void initClass(LLWorkerThread* workerthread);
+	static void cleanupClass();
+
+	static const std::string& getLastError();
+	static void setLastError(const std::string& message);
+	
+protected:
+	static LLMutex* sMutex;
+	static std::string sLastErrorMessage;
+};
+
+//============================================================================
+// Image base class
 
 class LLImageBase : public LLThreadSafeRefCount
 {
@@ -113,10 +132,6 @@ protected:
 	void setDataAndSize(U8 *data, S32 size) { mData = data; mDataSize = size; };
 	
 public:
-	static const std::string& getLastError() {return sLastErrorMessage;};
-	static void resetLastError() {sLastErrorMessage = "No Error"; };
-	static BOOL setLastError(const std::string& message, const std::string& filename = std::string()); // returns FALSE
-
 	static void generateMip(const U8 *indata, U8* mipdata, int width, int height, S32 nchannels);
 	
 	// Function for calculating the download priority for textures
@@ -141,8 +156,6 @@ private:
 public:
 	S16 mMemType; // debug
 	
-	static std::string sLastErrorMessage;
-
 	static BOOL sSizeOverride;
 };
 
@@ -245,7 +258,6 @@ public:
 	LLImageFormatted(S8 codec);
 
 	// LLImageBase
-public:
 	/*virtual*/ void deleteData();
 	/*virtual*/ U8* allocateData(S32 size = -1);
 	/*virtual*/ U8* reallocateData(S32 size);
@@ -254,7 +266,6 @@ public:
 	/*virtual*/ void sanityCheck();
 
 	// New methods
-public:
 	// subclasses must return a prefered file extension (lowercase without a leading dot)
 	virtual std::string getExtension() = 0;
 	// calcHeaderSize() returns the maximum size of header;
@@ -287,6 +298,10 @@ public:
 	void setDiscardLevel(S8 discard_level) { mDiscardLevel = discard_level; }
 	S8 getDiscardLevel() const { return mDiscardLevel; }
 
+	// setLastError needs to be deferred for J2C images since it may be called from a DLL
+	virtual void resetLastError();
+	virtual void setLastError(const std::string& message, const std::string& filename = std::string());
+	
 protected:
 	BOOL copyData(U8 *data, S32 size); // calls updateData()
 	
@@ -295,7 +310,7 @@ protected:
 	S8 mDecoding;
 	S8 mDecoded;
 	S8 mDiscardLevel;
-
+	
 public:
 	static S32 sGlobalFormattedMemory;
 };
diff --git a/indra/llimage/llimagej2c.cpp b/indra/llimage/llimagej2c.cpp
index 73c5b111c3..3b3d08d3aa 100644
--- a/indra/llimage/llimagej2c.cpp
+++ b/indra/llimage/llimagej2c.cpp
@@ -219,32 +219,54 @@ LLImageJ2C::~LLImageJ2C()
 }
 
 // virtual
+void LLImageJ2C::resetLastError()
+{
+	mLastError.clear();
+}
+
+//virtual
+void LLImageJ2C::setLastError(const std::string& message, const std::string& filename)
+{
+	mLastError = message;
+	if (!filename.empty())
+		mLastError += std::string(" FILE: ") + filename;
+}
+
+// virtual
 S8  LLImageJ2C::getRawDiscardLevel()
 {
 	return mRawDiscardLevel;
 }
 
 BOOL LLImageJ2C::updateData()
-{	
+{
+	BOOL res = TRUE;
 	resetLastError();
 
 	// Check to make sure that this instance has been initialized with data
 	if (!getData() || (getDataSize() < 16))
 	{
 		setLastError("LLImageJ2C uninitialized");
-		return FALSE;
+		res = FALSE;
+	}
+	else 
+	{
+		res = mImpl->getMetadata(*this);
 	}
 
-	if (!mImpl->getMetadata(*this))
+	if (res)
 	{
-		return FALSE;
+		// SJB: override discard based on mMaxBytes elsewhere
+		S32 max_bytes = getDataSize(); // mMaxBytes ? mMaxBytes : getDataSize();
+		S32 discard = calcDiscardLevelBytes(max_bytes);
+		setDiscardLevel(discard);
 	}
-	// SJB: override discard based on mMaxBytes elsewhere
-	S32 max_bytes = getDataSize(); // mMaxBytes ? mMaxBytes : getDataSize();
-	S32 discard = calcDiscardLevelBytes(max_bytes);
-	setDiscardLevel(discard);
 
-	return TRUE;
+	if (!mLastError.empty())
+	{
+		LLImage::setLastError(mLastError);
+	}
+	return res;
 }
 
 
@@ -258,20 +280,24 @@ BOOL LLImageJ2C::decodeChannels(LLImageRaw *raw_imagep, F32 decode_time, S32 fir
 {
 	LLMemType mt1((LLMemType::EMemType)mMemType);
 
+	BOOL res = TRUE;
+	
 	resetLastError();
 
 	// Check to make sure that this instance has been initialized with data
 	if (!getData() || (getDataSize() < 16))
 	{
 		setLastError("LLImageJ2C uninitialized");
-		return FALSE;
+		res = FALSE;
 	}
-
-	// Update the raw discard level
-	updateRawDiscardLevel();
-
-	mDecoding = TRUE;
-	BOOL res = mImpl->decodeImpl(*this, *raw_imagep, decode_time, first_channel, max_channel_count);
+	else
+	{
+		// Update the raw discard level
+		updateRawDiscardLevel();
+		mDecoding = TRUE;
+		res = mImpl->decodeImpl(*this, *raw_imagep, decode_time, first_channel, max_channel_count);
+	}
+	
 	if (res)
 	{
 		if (!mDecoding)
@@ -283,9 +309,14 @@ BOOL LLImageJ2C::decodeChannels(LLImageRaw *raw_imagep, F32 decode_time, S32 fir
 		{
 			mDecoding = FALSE;
 		}
-		return TRUE; // done
 	}
-	return FALSE;
+
+	if (!mLastError.empty())
+	{
+		LLImage::setLastError(mLastError);
+	}
+	
+	return res;
 }
 
 
@@ -298,7 +329,13 @@ BOOL LLImageJ2C::encode(const LLImageRaw *raw_imagep, F32 encode_time)
 BOOL LLImageJ2C::encode(const LLImageRaw *raw_imagep, const char* comment_text, F32 encode_time)
 {
 	LLMemType mt1((LLMemType::EMemType)mMemType);
-	return mImpl->encodeImpl(*this, *raw_imagep, comment_text, encode_time, mReversible);
+	resetLastError();
+	BOOL res = mImpl->encodeImpl(*this, *raw_imagep, comment_text, encode_time, mReversible);
+	if (!mLastError.empty())
+	{
+		LLImage::setLastError(mLastError);
+	}
+	return res;
 }
 
 //static
@@ -376,6 +413,8 @@ void LLImageJ2C::setReversible(const BOOL reversible)
 
 BOOL LLImageJ2C::loadAndValidate(const std::string &filename)
 {
+	BOOL res = TRUE;
+	
 	resetLastError();
 
 	S32 file_size = 0;
@@ -383,27 +422,38 @@ BOOL LLImageJ2C::loadAndValidate(const std::string &filename)
 	if (!apr_file)
 	{
 		setLastError("Unable to open file for reading", filename);
-		return FALSE;
+		res = FALSE;
 	}
-	if (file_size == 0)
+	else if (file_size == 0)
 	{
 		setLastError("File is empty",filename);
 		apr_file_close(apr_file);
-		return FALSE;
+		res = FALSE;
 	}
-	
-	U8 *data = new U8[file_size];
-	apr_size_t bytes_read = file_size;
-	apr_status_t s = apr_file_read(apr_file, data, &bytes_read); // modifies bytes_read	
-	if (s != APR_SUCCESS || (S32)bytes_read != file_size)
+	else
 	{
-		delete[] data;
-		setLastError("Unable to read entire file");
-		return FALSE;
+		U8 *data = new U8[file_size];
+		apr_size_t bytes_read = file_size;
+		apr_status_t s = apr_file_read(apr_file, data, &bytes_read); // modifies bytes_read	
+		apr_file_close(apr_file);
+		if (s != APR_SUCCESS || (S32)bytes_read != file_size)
+		{
+			delete[] data;
+			setLastError("Unable to read entire file");
+			res = FALSE;
+		}
+		else
+		{
+			res = validate(data, file_size);
+		}
 	}
-	apr_file_close(apr_file);
 
-	return validate(data, file_size);
+	if (!mLastError.empty())
+	{
+		LLImage::setLastError(mLastError);
+	}
+	
+	return res;
 }
 
 
@@ -411,21 +461,30 @@ BOOL LLImageJ2C::validate(U8 *data, U32 file_size)
 {
 	LLMemType mt1((LLMemType::EMemType)mMemType);
 
+	resetLastError();
+	
 	setData(data, file_size);
+
 	BOOL res = updateData();
-	if ( !res )
+	if ( res )
 	{
-		return FALSE;
+		// Check to make sure that this instance has been initialized with data
+		if (!getData() || (0 == getDataSize()))
+		{
+			setLastError("LLImageJ2C uninitialized");
+			res = FALSE;
+		}
+		else
+		{
+			res = mImpl->getMetadata(*this);
+		}
 	}
-
-	// Check to make sure that this instance has been initialized with data
-	if (!getData() || (0 == getDataSize()))
+	
+	if (!mLastError.empty())
 	{
-		setLastError("LLImageJ2C uninitialized");
-		return FALSE;
+		LLImage::setLastError(mLastError);
 	}
-
-	return mImpl->getMetadata(*this);
+	return res;
 }
 
 void LLImageJ2C::decodeFailed()
diff --git a/indra/llimage/llimagej2c.h b/indra/llimage/llimagej2c.h
index 03172d344f..4dc39ccc36 100644
--- a/indra/llimage/llimagej2c.h
+++ b/indra/llimage/llimagej2c.h
@@ -54,6 +54,10 @@ public:
 	/*virtual*/ S32 calcDataSize(S32 discard_level = 0);
 	/*virtual*/ S32 calcDiscardLevelBytes(S32 bytes);
 	/*virtual*/ S8  getRawDiscardLevel();
+	// Override these so that we don't try to set a global variable from a DLL
+	/*virtual*/ void resetLastError();
+	/*virtual*/ void setLastError(const std::string& message, const std::string& filename = std::string());
+	
 	
 	// Encode with comment text 
 	BOOL encode(const LLImageRaw *raw_imagep, const char* comment_text, F32 encode_time=0.0);
@@ -86,6 +90,7 @@ protected:
 	F32 mRate;
 	BOOL mReversible;
 	LLImageJ2CImpl *mImpl;
+	std::string mLastError;
 };
 
 // Derive from this class to implement JPEG2000 decoding
diff --git a/indra/llimage/llimageworker.cpp b/indra/llimage/llimageworker.cpp
index cdec2bfe6c..cbc6ea7911 100644
--- a/indra/llimage/llimageworker.cpp
+++ b/indra/llimage/llimageworker.cpp
@@ -41,13 +41,13 @@ LLWorkerThread* LLImageWorker::sWorkerThread = NULL;
 S32 LLImageWorker::sCount = 0;
 
 //static
-void LLImageWorker::initClass(LLWorkerThread* workerthread)
+void LLImageWorker::initImageWorker(LLWorkerThread* workerthread)
 {
 	sWorkerThread = workerthread;
 }
 
 //static
-void LLImageWorker::cleanupClass()
+void LLImageWorker::cleanupImageWorker()
 {
 }
 
diff --git a/indra/llimage/llimageworker.h b/indra/llimage/llimageworker.h
index f9c592fa51..f3304130ea 100644
--- a/indra/llimage/llimageworker.h
+++ b/indra/llimage/llimageworker.h
@@ -38,8 +38,10 @@
 class LLImageWorker : public LLWorkerClass
 {
 public:
-	static void initClass(LLWorkerThread* workerthread);
-	static void cleanupClass();
+	static void initImageWorker(LLWorkerThread* workerthread);
+	static void cleanupImageWorker();
+	
+public:
 	static LLWorkerThread* getWorkerThread() { return sWorkerThread; }
 
 	// LLWorkerThread
diff --git a/indra/llmath/v3color.h b/indra/llmath/v3color.h
index e2a8274839..05f6186893 100644
--- a/indra/llmath/v3color.h
+++ b/indra/llmath/v3color.h
@@ -82,13 +82,23 @@ public:
 	
 	const LLColor3&	setToBlack();					// Clears LLColor3 to (0, 0, 0)
 	const LLColor3&	setToWhite();					// Zero LLColor3 to (0, 0, 0)
-	const LLColor3&	setVec(F32 x, F32 y, F32 z);	// Sets LLColor3 to (x, y, z)
-	const LLColor3&	setVec(const LLColor3 &vec);	// Sets LLColor3 to vec
-	const LLColor3&	setVec(const F32 *vec);			// Sets LLColor3 to vec
+	
+	const LLColor3&	setVec(F32 x, F32 y, F32 z);	// deprecated
+	const LLColor3&	setVec(const LLColor3 &vec);	// deprecated
+	const LLColor3&	setVec(const F32 *vec);			// deprecated
+
+	const LLColor3&	set(F32 x, F32 y, F32 z);	// Sets LLColor3 to (x, y, z)
+	const LLColor3&	set(const LLColor3 &vec);	// Sets LLColor3 to vec
+	const LLColor3&	set(const F32 *vec);		// Sets LLColor3 to vec
+
+	F32		magVec() const;				// deprecated
+	F32		magVecSquared() const;		// deprecated
+	F32		normVec();					// deprecated
+
+	F32		length() const;				// Returns magnitude of LLColor3
+	F32		lengthSquared() const;		// Returns magnitude squared of LLColor3
+	F32		normalize();				// Normalizes and returns the magnitude of LLColor3
 
-	F32		magVec() const;				// Returns magnitude of LLColor3
-	F32		magVecSquared() const;		// Returns magnitude squared of LLColor3
-	F32		normVec();					// Normalizes and returns the magnitude of LLColor3
 	F32		brightness() const;			// Returns brightness of LLColor3
 
 	const LLColor3&	operator=(const LLColor4 &a);
@@ -214,6 +224,31 @@ inline const LLColor3&	LLColor3::setToWhite(void)
 	return (*this);
 }
 
+inline const LLColor3&	LLColor3::set(F32 r, F32 g, F32 b)
+{
+	mV[0] = r;
+	mV[1] = g;
+	mV[2] = b;
+	return (*this);
+}
+
+inline const LLColor3&	LLColor3::set(const LLColor3 &vec)
+{
+	mV[0] = vec.mV[0];
+	mV[1] = vec.mV[1];
+	mV[2] = vec.mV[2];
+	return (*this);
+}
+
+inline const LLColor3&	LLColor3::set(const F32 *vec)
+{
+	mV[0] = vec[0];
+	mV[1] = vec[1];
+	mV[2] = vec[2];
+	return (*this);
+}
+
+// deprecated
 inline const LLColor3&	LLColor3::setVec(F32 r, F32 g, F32 b)
 {
 	mV[0] = r;
@@ -222,6 +257,7 @@ inline const LLColor3&	LLColor3::setVec(F32 r, F32 g, F32 b)
 	return (*this);
 }
 
+// deprecated
 inline const LLColor3&	LLColor3::setVec(const LLColor3 &vec)
 {
 	mV[0] = vec.mV[0];
@@ -230,6 +266,7 @@ inline const LLColor3&	LLColor3::setVec(const LLColor3 &vec)
 	return (*this);
 }
 
+// deprecated
 inline const LLColor3&	LLColor3::setVec(const F32 *vec)
 {
 	mV[0] = vec[0];
@@ -243,16 +280,44 @@ inline F32		LLColor3::brightness(void) const
 	return (mV[0] + mV[1] + mV[2]) / 3.0f;
 }
 
+inline F32		LLColor3::length(void) const
+{
+	return fsqrtf(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
+}
+
+inline F32		LLColor3::lengthSquared(void) const
+{
+	return mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2];
+}
+
+inline F32		LLColor3::normalize(void)
+{
+	F32 mag = fsqrtf(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
+	F32 oomag;
+
+	if (mag)
+	{
+		oomag = 1.f/mag;
+		mV[0] *= oomag;
+		mV[1] *= oomag;
+		mV[2] *= oomag;
+	}
+	return (mag);
+}
+
+// deprecated
 inline F32		LLColor3::magVec(void) const
 {
 	return fsqrtf(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
 }
 
+// deprecated
 inline F32		LLColor3::magVecSquared(void) const
 {
 	return mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2];
 }
 
+// deprecated
 inline F32		LLColor3::normVec(void)
 {
 	F32 mag = fsqrtf(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
diff --git a/indra/llmath/v4color.cpp b/indra/llmath/v4color.cpp
index 8ba329eaf2..c66fe66c92 100644
--- a/indra/llmath/v4color.cpp
+++ b/indra/llmath/v4color.cpp
@@ -161,6 +161,38 @@ LLColor4::LLColor4(const LLVector4& vector4)
 	mV[VW] = vector4.mV[VW];
 }
 
+const LLColor4&	LLColor4::set(const LLColor4U& color4u)
+{
+	const F32 SCALE = 1.f/255.f;
+	mV[VX] = color4u.mV[VX] * SCALE;
+	mV[VY] = color4u.mV[VY] * SCALE;
+	mV[VZ] = color4u.mV[VZ] * SCALE;
+	mV[VW] = color4u.mV[VW] * SCALE;
+	return (*this);
+}
+
+const LLColor4&	LLColor4::set(const LLColor3 &vec)
+{
+	mV[VX] = vec.mV[VX];
+	mV[VY] = vec.mV[VY];
+	mV[VZ] = vec.mV[VZ];
+
+//  no change to alpha!
+//	mV[VW] = 1.f;  
+
+	return (*this);
+}
+
+const LLColor4&	LLColor4::set(const LLColor3 &vec, F32 a)
+{
+	mV[VX] = vec.mV[VX];
+	mV[VY] = vec.mV[VY];
+	mV[VZ] = vec.mV[VZ];
+	mV[VW] = a;
+	return (*this);
+}
+
+// deprecated -- use set()
 const LLColor4&	LLColor4::setVec(const LLColor4U& color4u)
 {
 	const F32 SCALE = 1.f/255.f;
@@ -171,6 +203,7 @@ const LLColor4&	LLColor4::setVec(const LLColor4U& color4u)
 	return (*this);
 }
 
+// deprecated -- use set()
 const LLColor4&	LLColor4::setVec(const LLColor3 &vec)
 {
 	mV[VX] = vec.mV[VX];
@@ -183,6 +216,7 @@ const LLColor4&	LLColor4::setVec(const LLColor3 &vec)
 	return (*this);
 }
 
+// deprecated -- use set()
 const LLColor4&	LLColor4::setVec(const LLColor3 &vec, F32 a)
 {
 	mV[VX] = vec.mV[VX];
@@ -338,270 +372,270 @@ BOOL LLColor4::parseColor(const std::string& buf, LLColor4* color)
 		{
 			v = v * (1.f / 255.f);
 		}
-		color->setVec( v );
+		color->set( v );
 	}
 	else // Single value.  Read as a named color.
 	{
 		// We have a color name
 		if ( "red" == color_name )
 		{
-			color->setVec(LLColor4::red);
+			color->set(LLColor4::red);
 		}
 		else if ( "red1" == color_name )
 		{
-			color->setVec(LLColor4::red1);
+			color->set(LLColor4::red1);
 		}
 		else if ( "red2" == color_name )
 		{
-			color->setVec(LLColor4::red2);
+			color->set(LLColor4::red2);
 		}
 		else if ( "red3" == color_name )
 		{
-			color->setVec(LLColor4::red3);
+			color->set(LLColor4::red3);
 		}
 		else if ( "red4" == color_name )
 		{
-			color->setVec(LLColor4::red4);
+			color->set(LLColor4::red4);
 		}
 		else if ( "red5" == color_name )
 		{
-			color->setVec(LLColor4::red5);
+			color->set(LLColor4::red5);
 		}
 		else if( "green" == color_name )
 		{
-			color->setVec(LLColor4::green);
+			color->set(LLColor4::green);
 		}
 		else if( "green1" == color_name )
 		{
-			color->setVec(LLColor4::green1);
+			color->set(LLColor4::green1);
 		}
 		else if( "green2" == color_name )
 		{
-			color->setVec(LLColor4::green2);
+			color->set(LLColor4::green2);
 		}
 		else if( "green3" == color_name )
 		{
-			color->setVec(LLColor4::green3);
+			color->set(LLColor4::green3);
 		}
 		else if( "green4" == color_name )
 		{
-			color->setVec(LLColor4::green4);
+			color->set(LLColor4::green4);
 		}
 		else if( "green5" == color_name )
 		{
-			color->setVec(LLColor4::green5);
+			color->set(LLColor4::green5);
 		}
 		else if( "green6" == color_name )
 		{
-			color->setVec(LLColor4::green6);
+			color->set(LLColor4::green6);
 		}
 		else if( "blue" == color_name )
 		{
-			color->setVec(LLColor4::blue);
+			color->set(LLColor4::blue);
 		}
 		else if( "blue1" == color_name )
 		{
-			color->setVec(LLColor4::blue1);
+			color->set(LLColor4::blue1);
 		}
 		else if( "blue2" == color_name )
 		{
-			color->setVec(LLColor4::blue2);
+			color->set(LLColor4::blue2);
 		}
 		else if( "blue3" == color_name )
 		{
-			color->setVec(LLColor4::blue3);
+			color->set(LLColor4::blue3);
 		}
 		else if( "blue4" == color_name )
 		{
-			color->setVec(LLColor4::blue4);
+			color->set(LLColor4::blue4);
 		}
 		else if( "blue5" == color_name )
 		{
-			color->setVec(LLColor4::blue5);
+			color->set(LLColor4::blue5);
 		}
 		else if( "blue6" == color_name )
 		{
-			color->setVec(LLColor4::blue6);
+			color->set(LLColor4::blue6);
 		}
 		else if( "black" == color_name )
 		{
-			color->setVec(LLColor4::black);
+			color->set(LLColor4::black);
 		}
 		else if( "white" == color_name )
 		{
-			color->setVec(LLColor4::white);
+			color->set(LLColor4::white);
 		}
 		else if( "yellow" == color_name )
 		{
-			color->setVec(LLColor4::yellow);
+			color->set(LLColor4::yellow);
 		}
 		else if( "yellow1" == color_name )
 		{
-			color->setVec(LLColor4::yellow1);
+			color->set(LLColor4::yellow1);
 		}
 		else if( "yellow2" == color_name )
 		{
-			color->setVec(LLColor4::yellow2);
+			color->set(LLColor4::yellow2);
 		}
 		else if( "yellow3" == color_name )
 		{
-			color->setVec(LLColor4::yellow3);
+			color->set(LLColor4::yellow3);
 		}
 		else if( "yellow4" == color_name )
 		{
-			color->setVec(LLColor4::yellow4);
+			color->set(LLColor4::yellow4);
 		}
 		else if( "yellow5" == color_name )
 		{
-			color->setVec(LLColor4::yellow5);
+			color->set(LLColor4::yellow5);
 		}
 		else if( "yellow6" == color_name )
 		{
-			color->setVec(LLColor4::yellow6);
+			color->set(LLColor4::yellow6);
 		}
 		else if( "magenta" == color_name )
 		{
-			color->setVec(LLColor4::magenta);
+			color->set(LLColor4::magenta);
 		}
 		else if( "magenta1" == color_name )
 		{
-			color->setVec(LLColor4::magenta1);
+			color->set(LLColor4::magenta1);
 		}
 		else if( "magenta2" == color_name )
 		{
-			color->setVec(LLColor4::magenta2);
+			color->set(LLColor4::magenta2);
 		}
 		else if( "magenta3" == color_name )
 		{
-			color->setVec(LLColor4::magenta3);
+			color->set(LLColor4::magenta3);
 		}
 		else if( "magenta4" == color_name )
 		{
-			color->setVec(LLColor4::magenta4);
+			color->set(LLColor4::magenta4);
 		}
 		else if( "purple" == color_name )
 		{
-			color->setVec(LLColor4::purple);
+			color->set(LLColor4::purple);
 		}
 		else if( "purple1" == color_name )
 		{
-			color->setVec(LLColor4::purple1);
+			color->set(LLColor4::purple1);
 		}
 		else if( "purple2" == color_name )
 		{
-			color->setVec(LLColor4::purple2);
+			color->set(LLColor4::purple2);
 		}
 		else if( "purple3" == color_name )
 		{
-			color->setVec(LLColor4::purple3);
+			color->set(LLColor4::purple3);
 		}
 		else if( "purple4" == color_name )
 		{
-			color->setVec(LLColor4::purple4);
+			color->set(LLColor4::purple4);
 		}
 		else if( "purple5" == color_name )
 		{
-			color->setVec(LLColor4::purple5);
+			color->set(LLColor4::purple5);
 		}
 		else if( "purple6" == color_name )
 		{
-			color->setVec(LLColor4::purple6);
+			color->set(LLColor4::purple6);
 		}
 		else if( "pink" == color_name )
 		{
-			color->setVec(LLColor4::pink);
+			color->set(LLColor4::pink);
 		}
 		else if( "pink1" == color_name )
 		{
-			color->setVec(LLColor4::pink1);
+			color->set(LLColor4::pink1);
 		}
 		else if( "pink2" == color_name )
 		{
-			color->setVec(LLColor4::pink2);
+			color->set(LLColor4::pink2);
 		}
 		else if( "cyan" == color_name )
 		{
-			color->setVec(LLColor4::cyan);
+			color->set(LLColor4::cyan);
 		}
 		else if( "cyan1" == color_name )
 		{
-			color->setVec(LLColor4::cyan1);
+			color->set(LLColor4::cyan1);
 		}
 		else if( "cyan2" == color_name )
 		{
-			color->setVec(LLColor4::cyan2);
+			color->set(LLColor4::cyan2);
 		}
 		else if( "cyan3" == color_name )
 		{
-			color->setVec(LLColor4::cyan3);
+			color->set(LLColor4::cyan3);
 		}
 		else if( "cyan4" == color_name )
 		{
-			color->setVec(LLColor4::cyan4);
+			color->set(LLColor4::cyan4);
 		}
 		else if( "cyan5" == color_name )
 		{
-			color->setVec(LLColor4::cyan5);
+			color->set(LLColor4::cyan5);
 		}
 		else if( "cyan6" == color_name )
 		{
-			color->setVec(LLColor4::cyan6);
+			color->set(LLColor4::cyan6);
 		}
 		else if( "smoke" == color_name )
 		{
-			color->setVec(LLColor4::smoke);
+			color->set(LLColor4::smoke);
 		}
 		else if( "grey" == color_name )
 		{
-			color->setVec(LLColor4::grey);
+			color->set(LLColor4::grey);
 		}
 		else if( "grey1" == color_name )
 		{
-			color->setVec(LLColor4::grey1);
+			color->set(LLColor4::grey1);
 		}
 		else if( "grey2" == color_name )
 		{
-			color->setVec(LLColor4::grey2);
+			color->set(LLColor4::grey2);
 		}
 		else if( "grey3" == color_name )
 		{
-			color->setVec(LLColor4::grey3);
+			color->set(LLColor4::grey3);
 		}
 		else if( "grey4" == color_name )
 		{
-			color->setVec(LLColor4::grey4);
+			color->set(LLColor4::grey4);
 		}
 		else if( "orange" == color_name )
 		{
-			color->setVec(LLColor4::orange);
+			color->set(LLColor4::orange);
 		}
 		else if( "orange1" == color_name )
 		{
-			color->setVec(LLColor4::orange1);
+			color->set(LLColor4::orange1);
 		}
 		else if( "orange2" == color_name )
 		{
-			color->setVec(LLColor4::orange2);
+			color->set(LLColor4::orange2);
 		}
 		else if( "orange3" == color_name )
 		{
-			color->setVec(LLColor4::orange3);
+			color->set(LLColor4::orange3);
 		}
 		else if( "orange4" == color_name )
 		{
-			color->setVec(LLColor4::orange4);
+			color->set(LLColor4::orange4);
 		}
 		else if( "orange5" == color_name )
 		{
-			color->setVec(LLColor4::orange5);
+			color->set(LLColor4::orange5);
 		}
 		else if( "orange6" == color_name )
 		{
-			color->setVec(LLColor4::orange6);
+			color->set(LLColor4::orange6);
 		}
 		else if ( "clear" == color_name )
 		{
-			color->setVec(0.f, 0.f, 0.f, 0.f);
+			color->set(0.f, 0.f, 0.f, 0.f);
 		}
 		else
 		{
diff --git a/indra/llmath/v4color.h b/indra/llmath/v4color.h
index 62c0b663b8..98f04130d6 100644
--- a/indra/llmath/v4color.h
+++ b/indra/llmath/v4color.h
@@ -84,20 +84,33 @@ class LLColor4
 		const LLColor4&	setToBlack();						// zero LLColor4 to (0, 0, 0, 1)
 		const LLColor4&	setToWhite();						// zero LLColor4 to (0, 0, 0, 1)
 
-		const LLColor4&	setVec(F32 r, F32 g, F32 b, F32 a);	// Sets LLColor4 to (r, g, b, a)
-		const LLColor4&	setVec(F32 r, F32 g, F32 b);	// Sets LLColor4 to (r, g, b) (no change in a)
-		const LLColor4&	setVec(const LLColor4 &vec);	// Sets LLColor4 to vec
-		const LLColor4&	setVec(const LLColor3 &vec);	// Sets LLColor4 to LLColor3 vec (no change in alpha)
-		const LLColor4&	setVec(const LLColor3 &vec, F32 a);	// Sets LLColor4 to LLColor3 vec, with alpha specified
-		const LLColor4&	setVec(const F32 *vec);			// Sets LLColor4 to vec
-		const LLColor4&	setVec(const LLColor4U& color4u); // Sets LLColor4 to color4u, rescaled.
+		const LLColor4&	setVec(F32 r, F32 g, F32 b, F32 a);	// deprecated -- use set()
+		const LLColor4&	setVec(F32 r, F32 g, F32 b);		// deprecated -- use set()
+		const LLColor4&	setVec(const LLColor4 &vec);		// deprecated -- use set()
+		const LLColor4&	setVec(const LLColor3 &vec);		// deprecated -- use set()
+		const LLColor4&	setVec(const LLColor3 &vec, F32 a);	// deprecated -- use set()
+		const LLColor4&	setVec(const F32 *vec);				// deprecated -- use set()
+		const LLColor4&	setVec(const LLColor4U& color4u); 	// deprecated -- use set()
+
+		const LLColor4&	set(F32 r, F32 g, F32 b, F32 a);	// Sets LLColor4 to (r, g, b, a)
+		const LLColor4&	set(F32 r, F32 g, F32 b);	// Sets LLColor4 to (r, g, b) (no change in a)
+		const LLColor4&	set(const LLColor4 &vec);	// Sets LLColor4 to vec
+		const LLColor4&	set(const LLColor3 &vec);	// Sets LLColor4 to LLColor3 vec (no change in alpha)
+		const LLColor4&	set(const LLColor3 &vec, F32 a);	// Sets LLColor4 to LLColor3 vec, with alpha specified
+		const LLColor4&	set(const F32 *vec);			// Sets LLColor4 to vec
+		const LLColor4&	set(const LLColor4U& color4u); // Sets LLColor4 to color4u, rescaled.
 
 
 		const LLColor4&    setAlpha(F32 a);
 
-		F32			magVec() const;				// Returns magnitude of LLColor4
-		F32			magVecSquared() const;		// Returns magnitude squared of LLColor4
-		F32			normVec();					// Normalizes and returns the magnitude of LLColor4
+		F32			magVec() const;				// deprecated -- use length()
+		F32			magVecSquared() const;		// deprecated -- use lengthSquared()
+		F32			normVec();					// deprecated -- use normalize()
+
+		F32			length() const;				// Returns magnitude of LLColor4
+		F32			lengthSquared() const;		// Returns magnitude squared of LLColor4
+		F32			normalize();				// deprecated -- use normalize()
+
 		BOOL		isOpaque() { return mV[VALPHA] == 1.f; }
 
 		F32 operator[](int idx) const { return mV[idx]; }
@@ -289,6 +302,47 @@ inline const LLColor4&	LLColor4::setToWhite(void)
 	return (*this);
 }
 
+inline const LLColor4&	LLColor4::set(F32 x, F32 y, F32 z)
+{
+	mV[VX] = x;
+	mV[VY] = y;
+	mV[VZ] = z;
+
+//  no change to alpha!
+//	mV[VW] = 1.f;  
+
+	return (*this);
+}
+
+inline const LLColor4&	LLColor4::set(F32 x, F32 y, F32 z, F32 a)
+{
+	mV[VX] = x;
+	mV[VY] = y;
+	mV[VZ] = z;
+	mV[VW] = a;  
+	return (*this);
+}
+
+inline const LLColor4&	LLColor4::set(const LLColor4 &vec)
+{
+	mV[VX] = vec.mV[VX];
+	mV[VY] = vec.mV[VY];
+	mV[VZ] = vec.mV[VZ];
+	mV[VW] = vec.mV[VW];
+	return (*this);
+}
+
+
+inline const LLColor4&	LLColor4::set(const F32 *vec)
+{
+	mV[VX] = vec[VX];
+	mV[VY] = vec[VY];
+	mV[VZ] = vec[VZ];
+	mV[VW] = vec[VW];
+	return (*this);
+}
+
+// deprecated
 inline const LLColor4&	LLColor4::setVec(F32 x, F32 y, F32 z)
 {
 	mV[VX] = x;
@@ -301,6 +355,7 @@ inline const LLColor4&	LLColor4::setVec(F32 x, F32 y, F32 z)
 	return (*this);
 }
 
+// deprecated
 inline const LLColor4&	LLColor4::setVec(F32 x, F32 y, F32 z, F32 a)
 {
 	mV[VX] = x;
@@ -310,6 +365,7 @@ inline const LLColor4&	LLColor4::setVec(F32 x, F32 y, F32 z, F32 a)
 	return (*this);
 }
 
+// deprecated
 inline const LLColor4&	LLColor4::setVec(const LLColor4 &vec)
 {
 	mV[VX] = vec.mV[VX];
@@ -320,6 +376,7 @@ inline const LLColor4&	LLColor4::setVec(const LLColor4 &vec)
 }
 
 
+// deprecated
 inline const LLColor4&	LLColor4::setVec(const F32 *vec)
 {
 	mV[VX] = vec[VX];
@@ -337,16 +394,44 @@ inline const LLColor4&	LLColor4::setAlpha(F32 a)
 
 // LLColor4 Magnitude and Normalization Functions
 
+inline F32		LLColor4::length(void) const
+{
+	return fsqrtf(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+}
+
+inline F32		LLColor4::lengthSquared(void) const
+{
+	return mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ];
+}
+
+inline F32		LLColor4::normalize(void)
+{
+	F32 mag = fsqrtf(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+	F32 oomag;
+
+	if (mag)
+	{
+		oomag = 1.f/mag;
+		mV[VX] *= oomag;
+		mV[VY] *= oomag;
+		mV[VZ] *= oomag;
+	}
+	return (mag);
+}
+
+// deprecated
 inline F32		LLColor4::magVec(void) const
 {
 	return fsqrtf(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
 }
 
+// deprecated
 inline F32		LLColor4::magVecSquared(void) const
 {
 	return mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ];
 }
 
+// deprecated
 inline F32		LLColor4::normVec(void)
 {
 	F32 mag = fsqrtf(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
@@ -497,13 +582,13 @@ inline const LLColor4& operator%=(LLColor4 &a, F32 k)
 inline F32		distVec(const LLColor4 &a, const LLColor4 &b)
 {
 	LLColor4 vec = a - b;
-	return (vec.magVec());
+	return (vec.length());
 }
 
 inline F32		distVec_squared(const LLColor4 &a, const LLColor4 &b)
 {
 	LLColor4 vec = a - b;
-	return (vec.magVecSquared());
+	return (vec.lengthSquared());
 }
 
 inline LLColor4 lerp(const LLColor4 &a, const LLColor4 &b, F32 u)
diff --git a/indra/llmath/v4coloru.cpp b/indra/llmath/v4coloru.cpp
index 26f3804209..17a198b392 100644
--- a/indra/llmath/v4coloru.cpp
+++ b/indra/llmath/v4coloru.cpp
@@ -120,6 +120,6 @@ BOOL LLColor4U::parseColor4U(const std::string& buf, LLColor4U* value)
 		}
 	}
 
-	value->setVec( U8(v[0]), U8(v[1]), U8(v[2]), U8(v[3]) );
+	value->set( U8(v[0]), U8(v[1]), U8(v[2]), U8(v[3]) );
 	return TRUE;
 }
diff --git a/indra/llmath/v4coloru.h b/indra/llmath/v4coloru.h
index 1d3f31e968..aa830e0035 100644
--- a/indra/llmath/v4coloru.h
+++ b/indra/llmath/v4coloru.h
@@ -97,15 +97,23 @@ public:
 	const LLColor4U&	setToBlack();						// zero LLColor4U to (0, 0, 0, 1)
 	const LLColor4U&	setToWhite();						// zero LLColor4U to (0, 0, 0, 1)
 
-	const LLColor4U&	setVec(U8 r, U8 g, U8 b, U8 a);	// Sets LLColor4U to (r, g, b, a)
-	const LLColor4U&	setVec(U8 r, U8 g, U8 b);	// Sets LLColor4U to (r, g, b) (no change in a)
-	const LLColor4U&	setVec(const LLColor4U &vec);	// Sets LLColor4U to vec
-	const LLColor4U&	setVec(const U8 *vec);			// Sets LLColor4U to vec
+	const LLColor4U&	set(U8 r, U8 g, U8 b, U8 a);// Sets LLColor4U to (r, g, b, a)
+	const LLColor4U&	set(U8 r, U8 g, U8 b);		// Sets LLColor4U to (r, g, b) (no change in a)
+	const LLColor4U&	set(const LLColor4U &vec);	// Sets LLColor4U to vec
+	const LLColor4U&	set(const U8 *vec);			// Sets LLColor4U to vec
+
+	const LLColor4U&	setVec(U8 r, U8 g, U8 b, U8 a);	// deprecated -- use set()
+	const LLColor4U&	setVec(U8 r, U8 g, U8 b);		// deprecated -- use set()
+	const LLColor4U&	setVec(const LLColor4U &vec);	// deprecated -- use set()
+	const LLColor4U&	setVec(const U8 *vec);			// deprecated -- use set()
 
 	const LLColor4U&    setAlpha(U8 a);
 
-	F32			magVec() const;				// Returns magnitude of LLColor4U
-	F32			magVecSquared() const;		// Returns magnitude squared of LLColor4U
+	F32			magVec() const;				// deprecated -- use length()
+	F32			magVecSquared() const;		// deprecated -- use lengthSquared()
+
+	F32			length() const;				// Returns magnitude squared of LLColor4U
+	F32			lengthSquared() const;		// Returns magnitude squared of LLColor4U
 
 	friend std::ostream&	 operator<<(std::ostream& s, const LLColor4U &a);		// Print a
 	friend LLColor4U operator+(const LLColor4U &a, const LLColor4U &b);	// Return vector a + b
@@ -199,7 +207,7 @@ inline const LLColor4U&	LLColor4U::setToWhite(void)
 	return (*this);
 }
 
-inline const LLColor4U&	LLColor4U::setVec(const U8 x, const U8 y, const U8 z)
+inline const LLColor4U&	LLColor4U::set(const U8 x, const U8 y, const U8 z)
 {
 	mV[VX] = x;
 	mV[VY] = y;
@@ -211,7 +219,7 @@ inline const LLColor4U&	LLColor4U::setVec(const U8 x, const U8 y, const U8 z)
 	return (*this);
 }
 
-inline const LLColor4U&	LLColor4U::setVec(const U8 r, const U8 g, const U8 b, U8 a)
+inline const LLColor4U&	LLColor4U::set(const U8 r, const U8 g, const U8 b, U8 a)
 {
 	mV[0] = r;
 	mV[1] = g;
@@ -220,7 +228,7 @@ inline const LLColor4U&	LLColor4U::setVec(const U8 r, const U8 g, const U8 b, U8
 	return (*this);
 }
 
-inline const LLColor4U&	LLColor4U::setVec(const LLColor4U &vec)
+inline const LLColor4U&	LLColor4U::set(const LLColor4U &vec)
 {
 	mV[VX] = vec.mV[VX];
 	mV[VY] = vec.mV[VY];
@@ -229,17 +237,49 @@ inline const LLColor4U&	LLColor4U::setVec(const LLColor4U &vec)
 	return (*this);
 }
 
-/*
-inline const LLColor4U&	LLColor4U::setVec(const LLColor4 &vec)
+inline const LLColor4U&	LLColor4U::set(const U8 *vec)
 {
-	mV[VX] = (U8) (llmin(1.f, vec.mV[VX]) * 255.f);
-	mV[VY] = (U8) (llmin(1.f, vec.mV[VY]) * 255.f);
-	mV[VZ] = (U8) (llmin(1.f, vec.mV[VZ]) * 255.f);
-	mV[VW] = (U8) (llmin(1.f, vec.mV[VW]) * 255.f);
+	mV[VX] = vec[VX];
+	mV[VY] = vec[VY];
+	mV[VZ] = vec[VZ];
+	mV[VW] = vec[VW];
 	return (*this);
 }
-*/
 
+// deprecated
+inline const LLColor4U&	LLColor4U::setVec(const U8 x, const U8 y, const U8 z)
+{
+	mV[VX] = x;
+	mV[VY] = y;
+	mV[VZ] = z;
+
+//  no change to alpha!
+//	mV[VW] = 255;  
+
+	return (*this);
+}
+
+// deprecated
+inline const LLColor4U&	LLColor4U::setVec(const U8 r, const U8 g, const U8 b, U8 a)
+{
+	mV[0] = r;
+	mV[1] = g;
+	mV[2] = b;
+	mV[3] = a;  
+	return (*this);
+}
+
+// deprecated
+inline const LLColor4U&	LLColor4U::setVec(const LLColor4U &vec)
+{
+	mV[VX] = vec.mV[VX];
+	mV[VY] = vec.mV[VY];
+	mV[VZ] = vec.mV[VZ];
+	mV[VW] = vec.mV[VW];
+	return (*this);
+}
+
+// deprecated
 inline const LLColor4U&	LLColor4U::setVec(const U8 *vec)
 {
 	mV[VX] = vec[VX];
@@ -256,13 +296,24 @@ inline const LLColor4U&	LLColor4U::setAlpha(U8 a)
 }
 
 // LLColor4U Magnitude and Normalization Functions
-// bookmark
 
+inline F32		LLColor4U::length(void) const
+{
+	return fsqrtf( ((F32)mV[VX]) * mV[VX] + ((F32)mV[VY]) * mV[VY] + ((F32)mV[VZ]) * mV[VZ] );
+}
+
+inline F32		LLColor4U::lengthSquared(void) const
+{
+	return ((F32)mV[VX]) * mV[VX] + ((F32)mV[VY]) * mV[VY] + ((F32)mV[VZ]) * mV[VZ];
+}
+
+// deprecated
 inline F32		LLColor4U::magVec(void) const
 {
 	return fsqrtf( ((F32)mV[VX]) * mV[VX] + ((F32)mV[VY]) * mV[VY] + ((F32)mV[VZ]) * mV[VZ] );
 }
 
+// deprecated
 inline F32		LLColor4U::magVecSquared(void) const
 {
 	return ((F32)mV[VX]) * mV[VX] + ((F32)mV[VY]) * mV[VY] + ((F32)mV[VZ]) * mV[VZ];
@@ -407,13 +458,13 @@ inline const LLColor4U& operator%=(LLColor4U &a, U8 k)
 inline F32		distVec(const LLColor4U &a, const LLColor4U &b)
 {
 	LLColor4U vec = a - b;
-	return (vec.magVec());
+	return (vec.length());
 }
 
 inline F32		distVec_squared(const LLColor4U &a, const LLColor4U &b)
 {
 	LLColor4U vec = a - b;
-	return (vec.magVecSquared());
+	return (vec.lengthSquared());
 }
 
 void LLColor4U::setVecScaleClamp(const LLColor4& color)
diff --git a/indra/llmessage/llcurl.cpp b/indra/llmessage/llcurl.cpp
index c3ffbcc8ed..8c7392090c 100644
--- a/indra/llmessage/llcurl.cpp
+++ b/indra/llmessage/llcurl.cpp
@@ -265,6 +265,10 @@ LLCurl::Easy* LLCurl::Easy::getEasy()
 		delete easy;
 		return NULL;
 	}
+	
+	// set no DMS caching as default for all easy handles. This prevents them adopting a
+	// multi handles cache if they are added to one.
+	curl_easy_setopt(easy->mCurlEasyHandle, CURLOPT_DNS_CACHE_TIMEOUT, 0);
 	++gCurlEasyCount;
 	return easy;
 }
diff --git a/indra/llmessage/llhttpassetstorage.cpp b/indra/llmessage/llhttpassetstorage.cpp
index 6332c247a9..bf76c17873 100644
--- a/indra/llmessage/llhttpassetstorage.cpp
+++ b/indra/llmessage/llhttpassetstorage.cpp
@@ -256,6 +256,10 @@ void LLHTTPAssetRequest::setupCurlHandle()
 			// disable use of proxy, which can't handle chunked transfers
 	}
 	mHTTPHeaders = curl_slist_append(mHTTPHeaders, "Pragma:");
+
+	// bug in curl causes DNS to be cached for too long a time, 0 sets it to never cache DNS results internally (to curl)
+	curl_easy_setopt(mCurlHandle, CURLOPT_DNS_CACHE_TIMEOUT, 0);
+	
 	// resist the temptation to explicitly add the Transfer-Encoding: chunked
 	// header here - invokes a libCURL bug
 	curl_easy_setopt(mCurlHandle, CURLOPT_HTTPHEADER, mHTTPHeaders);
diff --git a/indra/llmessage/llnamevalue.cpp b/indra/llmessage/llnamevalue.cpp
index 13dca3e51f..5875587186 100644
--- a/indra/llmessage/llnamevalue.cpp
+++ b/indra/llmessage/llnamevalue.cpp
@@ -896,7 +896,7 @@ void LLNameValue::setVec3(const LLVector3 &a)
 }
 
 
-std::string LLNameValue::printNameValue()
+std::string LLNameValue::printNameValue() const
 {
 	std::string buffer;
 	buffer = llformat("%s %s %s %s ", mName, mStringType, mStringClass, mStringSendto);
@@ -905,7 +905,7 @@ std::string LLNameValue::printNameValue()
 	return buffer;
 }
 
-std::string LLNameValue::printData()
+std::string LLNameValue::printData() const
 {
 	std::string buffer;
 	switch(mType)
diff --git a/indra/llmessage/llnamevalue.h b/indra/llmessage/llnamevalue.h
index f50ed08207..f492015b4a 100644
--- a/indra/llmessage/llnamevalue.h
+++ b/indra/llmessage/llnamevalue.h
@@ -148,8 +148,8 @@ public:
 	BOOL			sendToViewer() const;
 
 	void			callCallback();
-	std::string		printNameValue();
-	std::string		printData();
+	std::string		printNameValue() const;
+	std::string		printData() const;
 	
 	ENameValueType		getTypeEnum() const		{ return mType; }
 	ENameValueClass		getClassEnum() const	{ return mClass; }
diff --git a/indra/llui/lllineeditor.cpp b/indra/llui/lllineeditor.cpp
index bacfe67ad8..a41b2af2b4 100644
--- a/indra/llui/lllineeditor.cpp
+++ b/indra/llui/lllineeditor.cpp
@@ -2282,7 +2282,7 @@ LLView* LLLineEditor::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory
 }
 
 //static
-void LLLineEditor::cleanupClass()
+void LLLineEditor::cleanupLineEditor()
 {
 	sImage = NULL;
 }
diff --git a/indra/llui/lllineeditor.h b/indra/llui/lllineeditor.h
index c2dbedd3f5..98242a493d 100644
--- a/indra/llui/lllineeditor.h
+++ b/indra/llui/lllineeditor.h
@@ -82,7 +82,7 @@ public:
 	virtual LLXMLNodePtr getXML(bool save_children = true) const;
 	void setColorParameters(LLXMLNodePtr node);
 	static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
-	static void cleanupClass();
+	static void cleanupLineEditor();
 
 	// mousehandler overrides
 	/*virtual*/ BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
diff --git a/indra/llui/llui.cpp b/indra/llui/llui.cpp
index 2b6895aa09..f34c48b729 100644
--- a/indra/llui/llui.cpp
+++ b/indra/llui/llui.cpp
@@ -1575,7 +1575,7 @@ void LLUI::initClass(LLControlGroup* config,
 void LLUI::cleanupClass()
 {
 	sImageProvider->cleanUp();
-	LLLineEditor::cleanupClass();
+	LLLineEditor::cleanupLineEditor();
 }
 
 
diff --git a/indra/lscript/lscript_byteconvert.h b/indra/lscript/lscript_byteconvert.h
index b5e09602c7..9344a1e90a 100644
--- a/indra/lscript/lscript_byteconvert.h
+++ b/indra/lscript/lscript_byteconvert.h
@@ -250,7 +250,7 @@ inline void bytestream2vector(LLVector3 &vector, const U8 *stream, S32 &offset)
 	}
 }
 
-inline void vector2bytestream(U8 *stream, S32 &offset, LLVector3 &vector)
+inline void vector2bytestream(U8 *stream, S32 &offset, const LLVector3 &vector)
 {
 	S32 value = *(S32 *)&vector.mV[VZ];
 	integer2bytestream(stream, offset, value);
@@ -292,7 +292,7 @@ inline void bytestream2quaternion(LLQuaternion &quat, const U8 *stream, S32 &off
 	}
 }
 
-inline void quaternion2bytestream(U8 *stream, S32 &offset, LLQuaternion &quat)
+inline void quaternion2bytestream(U8 *stream, S32 &offset, const LLQuaternion &quat)
 {
 	S32 value = *(S32 *)&quat.mQ[VS];
 	integer2bytestream(stream, offset, value);
@@ -528,7 +528,7 @@ inline void lscript_push(U8 *stream, F32 value)
 	}
 }
 
-inline void lscript_push(U8 *stream, LLVector3 &value)
+inline void lscript_push(U8 *stream, const LLVector3 &value)
 {
 	S32 sp = get_register(stream, LREG_SP);
 	sp -= LSCRIPTDataSize[LST_VECTOR];
@@ -539,7 +539,7 @@ inline void lscript_push(U8 *stream, LLVector3 &value)
 	}
 }
 
-inline void lscript_push(U8 *stream, LLQuaternion &value)
+inline void lscript_push(U8 *stream, const LLQuaternion &value)
 {
 	S32 sp = get_register(stream, LREG_SP);
 	sp -= LSCRIPTDataSize[LST_QUATERNION];
@@ -679,13 +679,13 @@ inline void lscript_local_store(U8 *stream, S32 address, F32 value)
 		float2bytestream(stream, address, value);
 }
 
-inline void lscript_local_store(U8 *stream, S32 address, LLVector3 value)
+inline void lscript_local_store(U8 *stream, S32 address, const LLVector3 value)
 {
 	if (lscript_check_local(stream, address, LSCRIPTDataSize[LST_VECTOR]))
 		vector2bytestream(stream, address, value);
 }
 
-inline void lscript_local_store(U8 *stream, S32 address, LLQuaternion value)
+inline void lscript_local_store(U8 *stream, S32 address, const LLQuaternion value)
 {
 	if (lscript_check_local(stream, address, LSCRIPTDataSize[LST_QUATERNION]))
 		quaternion2bytestream(stream, address, value);
@@ -703,13 +703,13 @@ inline void lscript_global_store(U8 *stream, S32 address, F32 value)
 		float2bytestream(stream, address, value);
 }
 
-inline void lscript_global_store(U8 *stream, S32 address, LLVector3 value)
+inline void lscript_global_store(U8 *stream, S32 address, const LLVector3 value)
 {
 	if (lscript_check_global(stream, address, LSCRIPTDataSize[LST_VECTOR]))
 		vector2bytestream(stream, address, value);
 }
 
-inline void lscript_global_store(U8 *stream, S32 address, LLQuaternion value)
+inline void lscript_global_store(U8 *stream, S32 address, const LLQuaternion value)
 {
 	if (lscript_check_global(stream, address, LSCRIPTDataSize[LST_QUATERNION]))
 		quaternion2bytestream(stream, address, value);
@@ -1125,7 +1125,7 @@ inline void safe_instruction_bytestream2vector(LLVector3 &value, U8 *stream, S32
 	}
 }
 
-inline void safe_instruction_vector2bytestream(U8 *stream, S32 &offset, LLVector3 &value)
+inline void safe_instruction_vector2bytestream(U8 *stream, S32 &offset, const LLVector3 &value)
 {
 	if (safe_instruction_check_address(stream, offset, LSCRIPTDataSize[LST_VECTOR]))
 	{
@@ -1141,7 +1141,7 @@ inline void safe_instruction_bytestream2quaternion(LLQuaternion &value, U8 *stre
 	}
 }
 
-inline void safe_instruction_quaternion2bytestream(U8 *stream, S32 &offset, LLQuaternion &value)
+inline void safe_instruction_quaternion2bytestream(U8 *stream, S32 &offset, const LLQuaternion &value)
 {
 	if (safe_instruction_check_address(stream, offset, LSCRIPTDataSize[LST_QUATERNION]))
 	{
diff --git a/indra/lscript/lscript_byteformat.h b/indra/lscript/lscript_byteformat.h
index 474e8a67a6..09033615d4 100644
--- a/indra/lscript/lscript_byteformat.h
+++ b/indra/lscript/lscript_byteformat.h
@@ -470,6 +470,7 @@ const U8 LSCRIPTTypeHi4Bits[LST_EOF] =
 	LST_VECTOR << 4,
 	LST_QUATERNION << 4,
 	LST_LIST << 4,
+	LST_UNDEFINED << 4,
 };
 
 const char * const LSCRIPTTypeNames[LST_EOF] = 	/*Flawfinder: ignore*/
diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt
index 1e8f37e75f..826538d8e2 100644
--- a/indra/newview/CMakeLists.txt
+++ b/indra/newview/CMakeLists.txt
@@ -198,6 +198,7 @@ set(viewer_SOURCE_FILES
     llglsandbox.cpp
     llgroupmgr.cpp
     llgroupnotify.cpp
+    llhomelocationresponder.cpp
     llhoverview.cpp
     llhudeffectbeam.cpp
     llhudeffect.cpp
@@ -590,6 +591,7 @@ set(viewer_HEADER_FILES
     llgivemoney.h
     llgroupmgr.h
     llgroupnotify.h
+    llhomelocationresponder.h
     llhoverview.h
     llhudeffect.h
     llhudeffectbeam.h
diff --git a/indra/newview/llagent.cpp b/indra/newview/llagent.cpp
index cb32dfb904..19a0676374 100644
--- a/indra/newview/llagent.cpp
+++ b/indra/newview/llagent.cpp
@@ -80,6 +80,7 @@
 #include "llfloatertools.h"
 #include "llfloaterworldmap.h"
 #include "llgroupmgr.h"
+#include "llhomelocationresponder.h"
 #include "llhudeffectlookat.h"
 #include "llhudmanager.h"
 #include "llinventorymodel.h"
@@ -90,6 +91,7 @@
 #include "llmoveview.h"
 #include "llnotify.h"
 #include "llquantize.h"
+#include "llsdutil.h"
 #include "llselectmgr.h"
 #include "llsky.h"
 #include "llrendersphere.h"
@@ -445,7 +447,7 @@ void LLAgent::init()
 	mCameraFocusOffsetTarget = LLVector4(gSavedSettings.getVector3("CameraOffsetBuild"));
 	mCameraOffsetDefault = gSavedSettings.getVector3("CameraOffsetDefault");
 //	mCameraOffsetNorm = mCameraOffsetDefault;
-//	mCameraOffsetNorm.normVec();
+//	mCameraOffsetNorm.normalize();
 	mCameraCollidePlane.clearVec();
 	mCurrentCameraDistance = mCameraOffsetDefault.magVec();
 	mTargetCameraDistance = mCurrentCameraDistance;
@@ -522,7 +524,7 @@ void LLAgent::resetView(BOOL reset_camera)
 			// leaving mouse-steer mode
 			LLVector3 agent_at_axis = getAtAxis();
 			agent_at_axis -= projected_vec(agent_at_axis, getReferenceUpVector());
-			agent_at_axis.normVec();
+			agent_at_axis.normalize();
 			gAgent.resetAxes(lerp(getAtAxis(), agent_at_axis, LLCriticalDamp::getInterpolant(0.3f)));
 		}
 
@@ -1033,7 +1035,7 @@ void LLAgent::slamLookAt(const LLVector3 &look_at)
 {
 	LLVector3 look_at_norm = look_at;
 	look_at_norm.mV[VZ] = 0.f;
-	look_at_norm.normVec();
+	look_at_norm.normalize();
 	resetAxes(look_at_norm);
 }
 
@@ -1305,7 +1307,7 @@ LLVector3 LLAgent::calcFocusOffset(LLViewerObject *object, S32 x, S32 y)
 
 	LLVector3 obj_dir_abs = obj_pos - LLViewerCamera::getInstance()->getOrigin();
 	obj_dir_abs.rotVec(inv_obj_rot);
-	obj_dir_abs.normVec();
+	obj_dir_abs.normalize();
 	obj_dir_abs.abs();
 
 	LLVector3 object_extents = object->getScale();
@@ -1330,7 +1332,7 @@ LLVector3 LLAgent::calcFocusOffset(LLViewerObject *object, S32 x, S32 y)
 	{
 		normal.setVec(obj_matrix.getUpRow4());
 	}
-	normal.normVec();
+	normal.normalize();
 
 	LLVector3d focus_pt_global;
 	// RN: should we check return value for valid pick?
@@ -1534,7 +1536,7 @@ BOOL LLAgent::calcCameraMinDistance(F32 &obj_min_distance)
 	camera_offset_target_abs_norm.abs();
 	// make sure offset is non-zero
 	camera_offset_target_abs_norm.clamp(0.001f, F32_MAX);
-	camera_offset_target_abs_norm.normVec();
+	camera_offset_target_abs_norm.normalize();
 
 	// find camera position relative to normalized object extents
 	LLVector3 camera_offset_target_scaled = camera_offset_target_abs_norm;
@@ -1580,7 +1582,7 @@ BOOL LLAgent::calcCameraMinDistance(F32 &obj_min_distance)
 	LLVector3 object_split_axis;
 	LLVector3 target_offset_scaled = target_offset_origin;
 	target_offset_scaled.abs();
-	target_offset_scaled.normVec();
+	target_offset_scaled.normalize();
 	target_offset_scaled.mV[VX] /= object_extents.mV[VX];
 	target_offset_scaled.mV[VY] /= object_extents.mV[VY];
 	target_offset_scaled.mV[VZ] /= object_extents.mV[VZ];
@@ -1703,7 +1705,7 @@ void LLAgent::setCameraZoomFraction(F32 fraction)
 	else if (cameraCustomizeAvatar())
 	{
 		LLVector3d camera_offset_dir = mCameraFocusOffsetTarget;
-		camera_offset_dir.normVec();
+		camera_offset_dir.normalize();
 		mCameraFocusOffsetTarget = camera_offset_dir * rescale(fraction, 0.f, 1.f, APPEARANCE_MAX_ZOOM, APPEARANCE_MIN_ZOOM);
 	}
 	else
@@ -1730,7 +1732,7 @@ void LLAgent::setCameraZoomFraction(F32 fraction)
 		}
 
 		LLVector3d camera_offset_dir = mCameraFocusOffsetTarget;
-		camera_offset_dir.normVec();
+		camera_offset_dir.normalize();
 		mCameraFocusOffsetTarget = camera_offset_dir * rescale(fraction, 0.f, 1.f, max_zoom, min_zoom);
 	}
 	startCameraAnimation();
@@ -1777,7 +1779,7 @@ void LLAgent::cameraOrbitOver(const F32 angle)
 	else
 	{
 		LLVector3 camera_offset_unit(mCameraFocusOffsetTarget);
-		camera_offset_unit.normVec();
+		camera_offset_unit.normalize();
 
 		F32 angle_from_up = acos( camera_offset_unit * getReferenceUpVector() );
 
@@ -1812,7 +1814,7 @@ void LLAgent::cameraZoomIn(const F32 fraction)
 	LLVector3d	camera_offset(mCameraFocusOffsetTarget);
 	LLVector3d	camera_offset_unit(mCameraFocusOffsetTarget);
 	F32 min_zoom = LAND_MIN_ZOOM;
-	F32 current_distance = (F32)camera_offset_unit.normVec();
+	F32 current_distance = (F32)camera_offset_unit.normalize();
 	F32 new_distance = current_distance * fraction;
 
 	// Don't move through focus point
@@ -1881,7 +1883,7 @@ void LLAgent::cameraOrbitIn(const F32 meters)
 	{
 		LLVector3d	camera_offset(mCameraFocusOffsetTarget);
 		LLVector3d	camera_offset_unit(mCameraFocusOffsetTarget);
-		F32 current_distance = (F32)camera_offset_unit.normVec();
+		F32 current_distance = (F32)camera_offset_unit.normalize();
 		F32 new_distance = current_distance - meters;
 		F32 min_zoom = LAND_MIN_ZOOM;
 		
@@ -2246,7 +2248,7 @@ void LLAgent::startAutoPilotGlobal(const LLVector3d &target_global, const std::s
 		mAutoPilotUseRotation = TRUE;
 		mAutoPilotTargetFacing = LLVector3::x_axis * *target_rotation;
 		mAutoPilotTargetFacing.mV[VZ] = 0.f;
-		mAutoPilotTargetFacing.normVec();
+		mAutoPilotTargetFacing.normalize();
 	}
 	else
 	{
@@ -2369,8 +2371,8 @@ void LLAgent::autoPilot(F32 *delta_yaw)
 		at.mV[VZ] = 0.f;
 		direction.mV[VZ] = 0.f;
 
-		at.normVec();
-		F32 xy_distance = direction.normVec();
+		at.normalize();
+		F32 xy_distance = direction.normalize();
 
 		F32 yaw = 0.f;
 		if (mAutoPilotTargetDist > mAutoPilotStopDistance)
@@ -3529,7 +3531,7 @@ void LLAgent::setupSitCamera()
 		// slam agent coordinate frame to proper parent local version
 		LLVector3 at_axis = mFrameAgent.getAtAxis();
 		at_axis.mV[VZ] = 0.f;
-		at_axis.normVec();
+		at_axis.normalize();
 		resetAxes(at_axis * ~parent_rot);
 	}
 }
@@ -3665,7 +3667,7 @@ LLVector3d LLAgent::calcCameraPositionTargetGlobal(BOOL *hit_limit)
 				// slam agent coordinate frame to proper parent local version
 				LLVector3 at_axis = mFrameAgent.getAtAxis() * parent_rot;
 				at_axis.mV[VZ] = 0.f;
-				at_axis.normVec();
+				at_axis.normalize();
 				resetAxes(at_axis * ~parent_rot);
 
 				local_camera_offset = local_camera_offset * mFrameAgent.getQuaternion() * parent_rot;
@@ -3686,7 +3688,7 @@ LLVector3d LLAgent::calcCameraPositionTargetGlobal(BOOL *hit_limit)
 					offset_dot_norm = 0.001f;
 				}
 				
-				camera_distance = local_camera_offset.normVec();
+				camera_distance = local_camera_offset.normalize();
 
 				F32 pos_dot_norm = getPosAgentFromGlobal(frame_center_global + head_offset) * plane_normal;
 				
@@ -3710,7 +3712,7 @@ LLVector3d LLAgent::calcCameraPositionTargetGlobal(BOOL *hit_limit)
 			}
 			else
 			{
-				camera_distance = local_camera_offset.normVec();
+				camera_distance = local_camera_offset.normalize();
 			}
 
 			mTargetCameraDistance = llmax(camera_distance, MIN_CAMERA_DISTANCE);
@@ -3745,7 +3747,7 @@ LLVector3d LLAgent::calcCameraPositionTargetGlobal(BOOL *hit_limit)
 				{
 					LLVector3 frame_at_axis = mFrameAgent.getAtAxis();
 					frame_at_axis -= projected_vec(frame_at_axis, getReferenceUpVector());
-					frame_at_axis.normVec();
+					frame_at_axis.normalize();
 
 					//transition smoothly in air mode, to avoid camera pop
 					F32 u = (time_in_air - GROUND_TO_AIR_CAMERA_TRANSITION_START_TIME) / GROUND_TO_AIR_CAMERA_TRANSITION_TIME;
@@ -3932,7 +3934,7 @@ void LLAgent::resetCamera()
 	// Remove any pitch from the avatar
 	LLVector3 at = mFrameAgent.getAtAxis();
 	at.mV[VZ] = 0.f;
-	at.normVec();
+	at.normalize();
 	gAgent.resetAxes(at);
 	// have to explicitly clear field of view zoom now
 	mCameraFOVZoomFactor = 0.f;
@@ -4147,14 +4149,14 @@ void LLAgent::changeCameraToThirdPerson(BOOL animate)
 		LLQuaternion obj_rot = ((LLViewerObject*)mAvatarObject->getParent())->getRenderRotation();
 		at_axis = LLViewerCamera::getInstance()->getAtAxis();
 		at_axis.mV[VZ] = 0.f;
-		at_axis.normVec();
+		at_axis.normalize();
 		resetAxes(at_axis * ~obj_rot);
 	}
 	else
 	{
 		at_axis = mFrameAgent.getAtAxis();
 		at_axis.mV[VZ] = 0.f;
-		at_axis.normVec();
+		at_axis.normalize();
 		resetAxes(at_axis);
 	}
 
@@ -4201,7 +4203,7 @@ void LLAgent::changeCameraToCustomizeAvatar(BOOL avatar_animate, BOOL camera_ani
 	// Remove any pitch from the avatar
 	//LLVector3 at = mFrameAgent.getAtAxis();
 	//at.mV[VZ] = 0.f;
-	//at.normVec();
+	//at.normalize();
 	//gAgent.resetAxes(at);
 
 	if( mCameraMode != CAMERA_MODE_CUSTOMIZE_AVATAR )
@@ -4228,7 +4230,7 @@ void LLAgent::changeCameraToCustomizeAvatar(BOOL avatar_animate, BOOL camera_ani
 				// Remove any pitch from the avatar
 			LLVector3 at = mFrameAgent.getAtAxis();
 			at.mV[VZ] = 0.f;
-			at.normVec();
+			at.normalize();
 			gAgent.resetAxes(at);
 
 			sendAnimationRequest(ANIM_AGENT_CUSTOMIZE, ANIM_REQUEST_START);
@@ -4508,14 +4510,14 @@ void LLAgent::setFocusOnAvatar(BOOL focus_on_avatar, BOOL animate)
 				LLQuaternion obj_rot = ((LLViewerObject*)mAvatarObject->getParent())->getRenderRotation();
 				at_axis = LLViewerCamera::getInstance()->getAtAxis();
 				at_axis.mV[VZ] = 0.f;
-				at_axis.normVec();
+				at_axis.normalize();
 				resetAxes(at_axis * ~obj_rot);
 			}
 			else
 			{
 				at_axis = LLViewerCamera::getInstance()->getAtAxis();
 				at_axis.mV[VZ] = 0.f;
-				at_axis.normVec();
+				at_axis.normalize();
 				resetAxes(at_axis);
 			}
 		}
@@ -4578,7 +4580,7 @@ void LLAgent::lookAtLastChat()
 			{
 				delta_pos = chatter->getPositionAgent() - getPositionAgent();
 			}
-			delta_pos.normVec();
+			delta_pos.normalize();
 
 			setControlFlags(AGENT_CONTROL_STOP);
 
@@ -4586,9 +4588,9 @@ void LLAgent::lookAtLastChat()
 
 			LLVector3 new_camera_pos = mAvatarObject->mHeadp->getWorldPosition();
 			LLVector3 left = delta_pos % LLVector3::z_axis;
-			left.normVec();
+			left.normalize();
 			LLVector3 up = left % delta_pos;
-			up.normVec();
+			up.normalize();
 			new_camera_pos -= delta_pos * 0.4f;
 			new_camera_pos += left * 0.3f;
 			new_camera_pos += up * 0.2f;
@@ -4607,7 +4609,7 @@ void LLAgent::lookAtLastChat()
 		else
 		{
 			delta_pos = chatter->getRenderPosition() - getPositionAgent();
-			delta_pos.normVec();
+			delta_pos.normalize();
 
 			setControlFlags(AGENT_CONTROL_STOP);
 
@@ -4615,9 +4617,9 @@ void LLAgent::lookAtLastChat()
 
 			LLVector3 new_camera_pos = mAvatarObject->mHeadp->getWorldPosition();
 			LLVector3 left = delta_pos % LLVector3::z_axis;
-			left.normVec();
+			left.normalize();
 			LLVector3 up = left % delta_pos;
-			up.normVec();
+			up.normalize();
 			new_camera_pos -= delta_pos * 0.4f;
 			new_camera_pos += left * 0.3f;
 			new_camera_pos += up * 0.2f;
@@ -4631,68 +4633,107 @@ void LLAgent::lookAtLastChat()
 
 const F32 SIT_POINT_EXTENTS = 0.2f;
 
-// Grabs current position
-void LLAgent::setStartPosition(U32 location_id)
-{
-	LLViewerObject		*object;
-
-	if ( !(gAgentID == LLUUID::null) )
-	{
-		// we've got an ID for an agent viewerobject
-		object = gObjectList.findObject(gAgentID);
-		if (object)
-		{
-			// we've got the viewer object
-			// Sometimes the agent can be velocity interpolated off of
-			// this simulator.  Clamp it to the region the agent is
-			// in, a little bit in on each side.
-			const F32 INSET = 0.5f;	//meters
-			const F32 REGION_WIDTH = LLWorld::getInstance()->getRegionWidthInMeters();
-
-			LLVector3 agent_pos = getPositionAgent();
-
-			if (mAvatarObject)
-			{
-				// the z height is at the agent's feet
-				agent_pos.mV[VZ] -= 0.5f * mAvatarObject->mBodySize.mV[VZ];
-			}
-
-			agent_pos.mV[VX] = llclamp( agent_pos.mV[VX], INSET, REGION_WIDTH - INSET );
-			agent_pos.mV[VY] = llclamp( agent_pos.mV[VY], INSET, REGION_WIDTH - INSET );
-
-			// Don't let them go below ground, or too high.
-			agent_pos.mV[VZ] = llclamp( agent_pos.mV[VZ], 
-				mRegionp->getLandHeightRegion( agent_pos ), 
-				LLWorld::getInstance()->getRegionMaxHeight() );
-
-			LLMessageSystem* msg = gMessageSystem;
-			msg->newMessageFast(_PREHASH_SetStartLocationRequest);
-			msg->nextBlockFast( _PREHASH_AgentData);
-			msg->addUUIDFast(_PREHASH_AgentID, getID());
-			msg->addUUIDFast(_PREHASH_SessionID, getSessionID());
-			msg->nextBlockFast( _PREHASH_StartLocationData);
-			// corrected by sim
-			msg->addStringFast(_PREHASH_SimName, "");
-			msg->addU32Fast(_PREHASH_LocationID, location_id);
-			msg->addVector3Fast(_PREHASH_LocationPos, agent_pos);
-			msg->addVector3Fast(_PREHASH_LocationLookAt,mFrameAgent.getAtAxis());
-
-			// Reliable only helps when setting home location.  Last
-			// location is sent on quit, and we don't have time to ack
-			// the packets.
-			msg->sendReliable(mRegionp->getHost());
-
-			const U32 HOME_INDEX = 1;
-			if( HOME_INDEX == location_id )
-			{
-				setHomePosRegion( mRegionp->getHandle(), getPositionAgent() );
-			}
-		}
-		else
-		{
-			llinfos << "setStartPosition - Can't find agent viewerobject id " << gAgentID << llendl;
-		}
-	}
+void LLAgent::setStartPosition( U32 location_id )
+{
+  LLViewerObject          *object;
+
+  if ( !(gAgentID == LLUUID::null) )
+  {
+    // we've got an ID for an agent viewerobject
+    object = gObjectList.findObject(gAgentID);
+    if (object)
+    {
+      // we've got the viewer object
+      // Sometimes the agent can be velocity interpolated off of
+      // this simulator.  Clamp it to the region the agent is
+      // in, a little bit in on each side.
+      const F32 INSET = 0.5f; //meters
+      const F32 REGION_WIDTH = LLWorld::getInstance()->getRegionWidthInMeters();
+
+      LLVector3 agent_pos = getPositionAgent();
+      LLVector3 agent_look_at = mFrameAgent.getAtAxis();
+
+      if (mAvatarObject)
+      {
+	// the z height is at the agent's feet
+	agent_pos.mV[VZ] -= 0.5f * mAvatarObject->mBodySize.mV[VZ];
+      }
+
+      agent_pos.mV[VX] = llclamp( agent_pos.mV[VX], INSET, REGION_WIDTH - INSET );
+      agent_pos.mV[VY] = llclamp( agent_pos.mV[VY], INSET, REGION_WIDTH - INSET );
+
+      // Don't let them go below ground, or too high.
+      agent_pos.mV[VZ] = llclamp( agent_pos.mV[VZ],
+				  mRegionp->getLandHeightRegion( agent_pos ),
+				  LLWorld::getInstance()->getRegionMaxHeight() );
+      // Send the CapReq
+
+      LLSD body;
+
+      std::string url = gAgent.getRegion()->getCapability("HomeLocation");
+      std::ostringstream strBuffer;
+      if( url.empty() )
+      {
+	LLMessageSystem* msg = gMessageSystem;
+	msg->newMessageFast(_PREHASH_SetStartLocationRequest);
+	msg->nextBlockFast( _PREHASH_AgentData);
+	msg->addUUIDFast(_PREHASH_AgentID, getID());
+	msg->addUUIDFast(_PREHASH_SessionID, getSessionID());
+	msg->nextBlockFast( _PREHASH_StartLocationData);
+	// corrected by sim
+	msg->addStringFast(_PREHASH_SimName, "");
+	msg->addU32Fast(_PREHASH_LocationID, location_id);
+	msg->addVector3Fast(_PREHASH_LocationPos, agent_pos);
+	msg->addVector3Fast(_PREHASH_LocationLookAt,mFrameAgent.getAtAxis());
+	
+	// Reliable only helps when setting home location.  Last
+	// location is sent on quit, and we don't have time to ack
+	// the packets.
+	msg->sendReliable(mRegionp->getHost());
+
+	const U32 HOME_INDEX = 1;
+	if( HOME_INDEX == location_id )
+	  {
+	    setHomePosRegion( mRegionp->getHandle(), getPositionAgent() );
+	  }
+      }
+      else
+      {
+	strBuffer << location_id;
+	body["HomeLocation"]["LocationId"] = strBuffer.str();
+
+	strBuffer.str("");
+	strBuffer << agent_pos.mV[VX];
+	body["HomeLocation"]["LocationPos"]["X"] = strBuffer.str();
+
+	strBuffer.str("");
+	strBuffer << agent_pos.mV[VY];
+	body["HomeLocation"]["LocationPos"]["Y"] = strBuffer.str();
+
+	strBuffer.str("");
+	strBuffer << agent_pos.mV[VZ];
+	body["HomeLocation"]["LocationPos"]["Z"] = strBuffer.str();
+
+	strBuffer.str("");
+	strBuffer << agent_look_at.mV[VX];
+	body["HomeLocation"]["LocationLookAt"]["X"] = strBuffer.str();
+
+	strBuffer.str("");
+	strBuffer << agent_look_at.mV[VY];
+	body["HomeLocation"]["LocationLookAt"]["Y"] = strBuffer.str();
+
+	strBuffer.str("");
+	strBuffer << agent_look_at.mV[VZ];
+	body["HomeLocation"]["LocationLookAt"]["Z"] = strBuffer.str();
+
+	LLHTTPClient::post( url, body, new LLHomeLocationResponder() );
+      }
+    }
+    else
+    {
+      llinfos << "setStartPosition - Can't find agent viewerobject id " << gAgentID << llendl;
+    }
+  }
 }
 
 void LLAgent::requestStopMotion( LLMotion* motion )
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 045e7ccf16..4c8ea54d8d 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -1366,8 +1366,7 @@ bool LLAppViewer::cleanup()
 	gImageList.shutdown(); // shutdown again in case a callback added something
 	
 	// This should eventually be done in LLAppViewer
-	LLImageJ2C::closeDSO();
-	LLImageFormatted::cleanupClass();
+	LLImage::cleanupClass();
 	LLVFSThread::cleanupClass();
 	LLLFSThread::cleanupClass();
 
@@ -1435,8 +1434,7 @@ bool LLAppViewer::initThreads()
 	LLAppViewer::sImageDecodeThread = new LLWorkerThread("ImageDecode", enable_threads && true);
 	LLAppViewer::sTextureCache = new LLTextureCache(enable_threads && true);
 	LLAppViewer::sTextureFetch = new LLTextureFetch(LLAppViewer::getTextureCache(), enable_threads && false);
-	LLImageWorker::initClass(LLAppViewer::getImageDecodeThread());
-	LLImageJ2C::openDSO();
+	LLImage::initClass(LLAppViewer::getImageDecodeThread());
 
 	// *FIX: no error handling here!
 	return true;
diff --git a/indra/newview/llhomelocationresponder.cpp b/indra/newview/llhomelocationresponder.cpp
new file mode 100644
index 0000000000..9eccc18ccd
--- /dev/null
+++ b/indra/newview/llhomelocationresponder.cpp
@@ -0,0 +1,108 @@
+/** 
+ * @file llhomelocationresponder.cpp
+ * @author Meadhbh Hamrick
+ * @brief Processes responses to the HomeLocation CapReq
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+/* File Inclusions */
+#include "llviewerprecompiledheaders.h"
+
+#include "llhomelocationresponder.h"
+#include "llsdutil.h"
+#include "llagent.h"
+#include "llviewerregion.h"
+
+void LLHomeLocationResponder::result( const LLSD& content )
+{
+  LLVector3 agent_pos;
+  bool      error = true;
+		
+  do {
+	
+    // was the call to /agent/<agent-id>/home-location successful?
+    // If not, we keep error set to true
+    if( ! content.has("success") )
+    {
+      break;
+    }
+		
+    if( 0 != strncmp("true", content["success"].asString().c_str(), 4 ) )
+    {
+      break;
+    }
+		
+    // did the simulator return a "justified" home location?
+    // If no, we keep error set to true
+    if( ! content.has( "HomeLocation" ) )
+    {
+      break;
+    }
+		
+    if( ! content["HomeLocation"].has("LocationPos") )
+    {
+      break;
+    }
+		
+    if( ! content["HomeLocation"]["LocationPos"].has("X") )
+    {
+      break;
+    }
+
+    agent_pos.mV[VX] = content["HomeLocation"]["LocationPos"]["X"].asInteger();
+		
+    if( ! content["HomeLocation"]["LocationPos"].has("Y") )
+    {
+      break;
+    }
+
+    agent_pos.mV[VY] = content["HomeLocation"]["LocationPos"]["Y"].asInteger();
+		
+    if( ! content["HomeLocation"]["LocationPos"].has("Z") )
+    {
+      break;
+    }
+
+    agent_pos.mV[VZ] = content["HomeLocation"]["LocationPos"]["Z"].asInteger();
+		
+    error = false;
+  } while( 0 );
+	
+  if( ! error )
+  {
+    llinfos << "setting home position" << llendl;
+		
+    LLViewerRegion *viewer_region = gAgent.getRegion();
+    gAgent.setHomePosRegion( viewer_region->getHandle(), agent_pos );
+  }
+}
+
+void LLHomeLocationResponder::error( const LLSD& content )
+{
+  llinfos << "received error(" << ll_pretty_print_sd( content ) << ")" << llendl;
+}
diff --git a/indra/newview/llhomelocationresponder.h b/indra/newview/llhomelocationresponder.h
new file mode 100644
index 0000000000..0851cb8fc1
--- /dev/null
+++ b/indra/newview/llhomelocationresponder.h
@@ -0,0 +1,47 @@
+/** 
+ * @file llhomelocationresponder.h
+ * @author Meadhbh Hamrick
+ * @brief Processes responses to the HomeLocation CapReq
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+ 
+ /* Macro Definitions */
+#ifndef LL_LLHOMELOCATIONRESPONDER_H
+#define LL_LLHOMELOCATIONRESPONDER_H
+
+/* File Inclusions */
+#include "llhttpclient.h"
+
+/* Typedef, Enum, Class, Struct, etc. */
+class LLHomeLocationResponder : public LLHTTPClient::Responder
+{
+	virtual void result( const LLSD& content );
+	virtual void error( const LLSD& content );
+};
+
+#endif
diff --git a/indra/newview/llinventorymodel.cpp b/indra/newview/llinventorymodel.cpp
index 9aa7f54fa9..b890781ab2 100644
--- a/indra/newview/llinventorymodel.cpp
+++ b/indra/newview/llinventorymodel.cpp
@@ -73,7 +73,6 @@ F32  LLInventoryModel::sMinTimeBetweenFetches = 0.3f;
 F32  LLInventoryModel::sMaxTimeBetweenFetches = 10.f;
 BOOL LLInventoryModel::sTimelyFetchPending = FALSE;
 LLFrameTimer LLInventoryModel::sFetchTimer;
-LLInventoryModel::cat_map_t LLInventoryModel::sBulkFetchMap;
 S16 LLInventoryModel::sBulkFetchCount = 0;
 
 // RN: for some reason, using std::queue in the header file confuses the compiler which things it's an xmlrpc_queue
@@ -1021,18 +1020,27 @@ void LLInventoryModel::fetchDescendentsOf(const LLUUID& folder_id)
 }
 
 //Initialize statics.
-LLAlertDialog* LLInventoryModel::fetchDescendentsResponder::sRetryDialog=NULL;
-LLSD LLInventoryModel::fetchDescendentsResponder::sRetrySD;
-
 bool LLInventoryModel::isBulkFetchProcessingComplete()
 {
 	return ( (sFetchQueue.empty() 
-			&& sBulkFetchMap.empty() 
-			&& sBulkFetchCount==0)  ?  TRUE : FALSE ) ;
+			&& sBulkFetchCount<=0)  ?  TRUE : FALSE ) ;
 }
 
+class fetchDescendentsResponder: public LLHTTPClient::Responder
+{
+	public:
+		fetchDescendentsResponder(const LLSD& request_sd) : mRequestSD(request_sd) {};
+		//fetchDescendentsResponder() {};
+		void result(const LLSD& content);
+		void error(U32 status, const std::string& reason);
+	public:
+		typedef std::vector<LLViewerInventoryCategory*> folder_ref_t;
+	protected:
+		LLSD mRequestSD;
+};
+
 //If we get back a normal response, handle it here
-void  LLInventoryModel::fetchDescendentsResponder::result(const LLSD& content)
+void  fetchDescendentsResponder::result(const LLSD& content)
 {	
 	if (content.has("folders"))	
 	{
@@ -1049,13 +1057,20 @@ void  LLInventoryModel::fetchDescendentsResponder::result(const LLSD& content)
 			{
 				llwarns << "Got a UpdateInventoryItem for the wrong agent."
 						<< llendl;
-				break;
+				continue;
 			}
 			LLUUID parent_id = folder_sd["folder-id"];
 			LLUUID owner_id = folder_sd["owner-id"];
 			S32    version  = (S32)folder_sd["version"].asInteger();
 			S32    descendents = (S32)folder_sd["descendents"].asInteger();
 			LLPointer<LLViewerInventoryCategory> tcategory = new LLViewerInventoryCategory(owner_id);
+
+	                LLViewerInventoryCategory* pcat = gInventory.getCategory(parent_id);
+			if (!pcat)
+			{
+				continue;
+			}
+
 			for(LLSD::array_const_iterator category_it = folder_sd["categories"].beginArray();
 				category_it != folder_sd["categories"].endArray();
 				++category_it)
@@ -1063,7 +1078,7 @@ void  LLInventoryModel::fetchDescendentsResponder::result(const LLSD& content)
 				LLSD category = *category_it;
 				tcategory->fromLLSD(category); 
 							
-				if (sFullFetchStarted)
+				if (LLInventoryModel::sFullFetchStarted)
 				{
 					sFetchQueue.push_back(tcategory->getUUID());
 				}
@@ -1111,21 +1126,21 @@ void  LLInventoryModel::fetchDescendentsResponder::result(const LLSD& content)
 
 	LLInventoryModel::incrBulkFetch(-1);
 	
-	if (isBulkFetchProcessingComplete())
+	if (LLInventoryModel::isBulkFetchProcessingComplete())
 	{
 		llinfos << "Inventory fetch completed" << llendl;
-		if (sFullFetchStarted)
+		if (LLInventoryModel::sFullFetchStarted)
 		{
-			sAllFoldersFetched = TRUE;
+			LLInventoryModel::sAllFoldersFetched = TRUE;
 		}
-		stopBackgroundFetch();
+		LLInventoryModel::stopBackgroundFetch();
 	}
 	
 	gInventory.notifyObservers();
 }
 
 //If we get back an error (not found, etc...), handle it here
-void LLInventoryModel::fetchDescendentsResponder::error(U32 status, const std::string& reason)
+void fetchDescendentsResponder::error(U32 status, const std::string& reason)
 {
 	llinfos << "fetchDescendentsResponder::error "
 		<< status << ": " << reason << llendl;
@@ -1139,63 +1154,24 @@ void LLInventoryModel::fetchDescendentsResponder::error(U32 status, const std::s
 			++folder_it)
 		{	
 			LLSD folder_sd = *folder_it;
-			sRetrySD["folders"].append(folder_sd);
-		}
-		sMinTimeBetweenFetches = 10.0f; //Add 10 seconds for every time out in this sequence.
-		
-		if (!sRetryDialog)			//The dialog isn't up.  Prompt the resident.
-		{
-			sRetryDialog = gViewerWindow->alertXml("RetryFetchInventoryDescendents", onClickRetry, this);
+			LLUUID folder_id = folder_sd["folder-id"];
+			sFetchQueue.push_front(folder_id);
 		}
 	}
 	else
 	{
-		if (isBulkFetchProcessingComplete())
+		if (LLInventoryModel::isBulkFetchProcessingComplete())
 		{
-			if (sFullFetchStarted)
+			if (LLInventoryModel::sFullFetchStarted)
 			{
-				sAllFoldersFetched = TRUE;
+				LLInventoryModel::sAllFoldersFetched = TRUE;
 			}
-			stopBackgroundFetch();
+			LLInventoryModel::stopBackgroundFetch();
 		}
 	}
 	gInventory.notifyObservers();
 }
 
-void LLInventoryModel::fetchDescendentsResponder::onClickRetry(S32 option, void* userdata)
-{
-	if (option == 0)
-	{
-		std::string url;
-
-		LLViewerRegion * agent_region = gAgent.getRegion();
-		if (agent_region)
-		{
-			url = agent_region->getCapability("FetchInventoryDescendents");
-		}
-
-		if (!url.empty()) //Capability found.  Build up LLSD and use it.
-		{
-			LLSD body = sRetrySD;
-			LLInventoryModel::incrBulkFetch(1);
-			LLHTTPClient::post(url, body, new LLInventoryModel::fetchDescendentsResponder(body),300);
-		}
-	}
-	else
-	{
-		if (isBulkFetchProcessingComplete())
-		{
-			if (sFullFetchStarted)
-			{
-				sAllFoldersFetched = TRUE;
-			}
-			stopBackgroundFetch();
-		}
-	}
-	sRetryDialog=NULL;
-	sRetrySD.clear();
-}
-
 //static   Bundle up a bunch of requests to send all at once.
 void LLInventoryModel::bulkFetch(std::string url)
 {
@@ -1206,7 +1182,7 @@ void LLInventoryModel::bulkFetch(std::string url)
 
 	S16 max_concurrent_fetches=8;
 	F32 new_min_time = 0.5f;			//HACK!  Clean this up when old code goes away entirely.
-	if (sMinTimeBetweenFetches <= new_min_time) sMinTimeBetweenFetches=new_min_time;  //HACK!  See above.
+	if (sMinTimeBetweenFetches < new_min_time) sMinTimeBetweenFetches=new_min_time;  //HACK!  See above.
 	
 	if(gDisconnected 
 	|| sBulkFetchCount > max_concurrent_fetches
@@ -1215,20 +1191,30 @@ void LLInventoryModel::bulkFetch(std::string url)
 		return; // just bail if we are disconnected.
 	}	
 
-	//HACK.  This is inelegant.  We're shuffling a dequeue to a map to get rid of 
-	//redundant requests.  When we get rid of the old code entirely, we can change
-	//the dequeue to a map.  In the new model, there is no benefit to queue order.
 	U32 folder_count=0;
-	U32 max_batch_size=10;
-	while( !(sFetchQueue.empty() ) )
+	U32 max_batch_size=5;
+
+	U32 sort_order = gSavedSettings.getU32("InventorySortOrder") & 0x1;
+
+	LLSD body;
+
+	while( !(sFetchQueue.empty() ) && (folder_count < max_batch_size) )
 	{
 		LLViewerInventoryCategory* cat = gInventory.getCategory(sFetchQueue.front());
 		
 		if (cat)
 		{
-			if ( !gInventory.isCategoryComplete(cat->getUUID()) )	//grab this folder.
+			if ( LLViewerInventoryCategory::VERSION_UNKNOWN == cat->getVersion())
 			{
-				sBulkFetchMap[(cat->getUUID())] = cat;
+				LLSD folder_sd;
+				folder_sd["folder-id"]		= cat->getUUID();
+				folder_sd["owner-id"]		= cat->getOwnerID();
+				folder_sd["sort-order"]		= (LLSD::Integer)sort_order;
+				folder_sd["fetch-folders"]	= (LLSD::Boolean)sFullFetchStarted;
+				folder_sd["fetch-items"]	= (LLSD::Boolean)TRUE;
+				body["folders"].append(folder_sd);
+
+				folder_count++;
 			}
 			else if (sFullFetchStarted)
 			{	//Already have this folder but append child folders to list.
@@ -1249,54 +1235,14 @@ void LLInventoryModel::bulkFetch(std::string url)
 		sFetchQueue.pop_front();
 	}
 		
-
-	if (!sBulkFetchMap.empty())	//There's stuff to fetch.
-	{
-		U32 sort_order = gSavedSettings.getU32("InventorySortOrder") & 0x1;
-
-		LLSD body;
-		
-		cat_map_t::iterator iter=sBulkFetchMap.begin();
-		while( iter!=sBulkFetchMap.end() && (folder_count < max_batch_size) )
-		{
-			LLViewerInventoryCategory* cat = iter->second;
-			
-			if (cat && !gInventory.isCategoryComplete(cat->getUUID()) ) 	//Category exists
-			{
-				BOOL fetchItems=TRUE;
-				if ( sFullFetchStarted 
-					&& gInventory.isCategoryComplete(cat->getUUID()) )
-				{
-					fetchItems=FALSE;
-				}
-				
-				LLSD folder_sd;
-				folder_sd["folder-id"]		= cat->getUUID();
-				folder_sd["owner-id"]		= cat->getOwnerID();
-				folder_sd["sort-order"]		= (LLSD::Integer)sort_order;
-				folder_sd["fetch-folders"]	= (LLSD::Boolean)sFullFetchStarted;
-				folder_sd["fetch-items"]	= (LLSD::Boolean)fetchItems;
-				body["folders"].append(folder_sd);
-
-				folder_count++;
-			}
-			sBulkFetchMap.erase(iter);
-			iter=sBulkFetchMap.begin();
-		}
-	
-		if (iter == sBulkFetchMap.end()) sBulkFetchMap.clear();
-		
 		if (folder_count > 0)
 		{
 			sBulkFetchCount++;
 			
-			LLHTTPClient::post(url, body, new LLInventoryModel::fetchDescendentsResponder(body));
+		LLHTTPClient::post(url, body, new fetchDescendentsResponder(body));
 			sFetchTimer.reset();
 		}
-		
-	}	
-	
-	if (isBulkFetchProcessingComplete())
+	else if (isBulkFetchProcessingComplete())
 	{
 		if (sFullFetchStarted)
 		{
@@ -1365,14 +1311,7 @@ void LLInventoryModel::backgroundFetch(void*)
 	if (sBackgroundFetchActive)
 	{
 		//If we'll be using the capability, we'll be sending batches and the background thing isn't as important.
-		std::string url;
-
-		LLViewerRegion * agent_region = gAgent.getRegion();
-		if (agent_region)
-		{
-			url = agent_region->getCapability("FetchInventoryDescendents");
-		}
-
+		std::string url = gAgent.getRegion()->getCapability("FetchInventoryDescendents");   
 		if (!url.empty()) 
 		{
 			bulkFetch(url);
diff --git a/indra/newview/llinventorymodel.h b/indra/newview/llinventorymodel.h
index 85eb46404b..4889d622dc 100644
--- a/indra/newview/llinventorymodel.h
+++ b/indra/newview/llinventorymodel.h
@@ -110,21 +110,7 @@ public:
 	LLInventoryModel();
 	~LLInventoryModel();
 
-	class fetchDescendentsResponder: public LLHTTPClient::Responder
-	{
-		public:
-			fetchDescendentsResponder(const LLSD& request_sd) : mRequestSD(request_sd) {};
-			void result(const LLSD& content);			
-			void error(U32 status, const std::string& reason);
-			static void onClickRetry(S32 option, void* userdata);
-			static void appendRetryList(LLSD retry_sd);
-		public:
-			typedef std::vector<LLViewerInventoryCategory*> folder_ref_t;
-		protected:
-			LLSD mRequestSD;
-			static LLSD sRetrySD;
-			static LLAlertDialog		*sRetryDialog;
-	};
+
 
 	//
 	// Accessors
@@ -364,7 +350,6 @@ public:
 	// start and stop background breadth-first fetching of inventory contents
 	// this gets triggered when performing a filter-search
 	static void startBackgroundFetch(const LLUUID& cat_id = LLUUID::null); // start fetch process
-	static void stopBackgroundFetch(); // stop fetch process
 	static BOOL backgroundFetchActive();
 	static bool isEverythingFetched();
 	static void backgroundFetch(void*); // background fetch idle function
@@ -413,7 +398,6 @@ protected:
 	static void processInventoryDescendents(LLMessageSystem* msg, void**);
 	static void processMoveInventoryItem(LLMessageSystem* msg, void**);
 	static void processFetchInventoryReply(LLMessageSystem* msg, void**);
-	static bool isBulkFetchProcessingComplete();
 	
 	bool messageUpdateCore(LLMessageSystem* msg, bool do_accounting);
 
@@ -447,11 +431,8 @@ protected:
 	observer_list_t mObservers;
 
 	// completing the fetch once per session should be sufficient
-	static cat_map_t sBulkFetchMap;
 	static BOOL sBackgroundFetchActive;
 	static BOOL sTimelyFetchPending;
-	static BOOL sAllFoldersFetched; 
-	static BOOL sFullFetchStarted;
 	static S32  sNumFetchRetries;
 	static LLFrameTimer sFetchTimer;
 	static F32 sMinTimeBetweenFetches;
@@ -464,6 +445,11 @@ protected:
 public:
 	// *NOTE: DEBUG functionality
 	void dumpInventory();
+	static bool isBulkFetchProcessingComplete();
+	static void stopBackgroundFetch(); // stop fetch process
+
+	static BOOL sFullFetchStarted;
+	static BOOL sAllFoldersFetched; 
 };
 
 // a special inventory model for the agent
diff --git a/indra/newview/llpanelgrouplandmoney.cpp b/indra/newview/llpanelgrouplandmoney.cpp
index 8483e43394..84ba2dd807 100644
--- a/indra/newview/llpanelgrouplandmoney.cpp
+++ b/indra/newview/llpanelgrouplandmoney.cpp
@@ -705,12 +705,13 @@ BOOL LLPanelGroupLandMoney::postBuild()
 	textp = getChild<LLTextEditor>("group_money_planning_text", true);
 	panelp = getChild<LLPanel>("group_money_planning_tab", true);
 
-	if ( !can_view )
+	if ( 1 ) //!can_view
 	{
 		textp->setText(mImplementationp->mCantViewAccountsText);
 	}
 	else
 	{
+		//Temporally disabled for DEV-11287.
 		mImplementationp->mMoneyPlanningTabEHp = 
 			new LLGroupMoneyPlanningTabEventHandler(textp,
 													tabcp,
diff --git a/indra/newview/llsprite.cpp b/indra/newview/llsprite.cpp
index 1348f85201..c8a3904d96 100644
--- a/indra/newview/llsprite.cpp
+++ b/indra/newview/llsprite.cpp
@@ -126,8 +126,8 @@ void LLSprite::updateFace(LLFace &face)
 			LLVector3 camera_vec = mPosition - sCameraPosition;
 			mScaledRight = camera_vec % LLVector3(0.f, 0.f, 1.f);
 			mScaledUp = -(camera_vec % mScaledRight);
-			mScaledUp.normVec();
-			mScaledRight.normVec();
+			mScaledUp.normalize();
+			mScaledRight.normalize();
 			mScaledUp *= mHeightDiv2;
 			mScaledRight *= mWidthDiv2;
 
@@ -156,7 +156,7 @@ void LLSprite::updateFace(LLFace &face)
 		else
 		{
 			x_axis = sNormal % LLVector3(0.f, -1.f, 0.f);
-			x_axis.normVec();
+			x_axis.normalize();
 
 			y_axis = sNormal % x_axis;
 		}
diff --git a/indra/newview/llsprite.h b/indra/newview/llsprite.h
index 322150e85b..03026fd071 100644
--- a/indra/newview/llsprite.h
+++ b/indra/newview/llsprite.h
@@ -73,7 +73,7 @@ public:
 	void setColor(const LLColor4 &color);
 	void setColor(const F32 r, const F32 g, const F32 b, const F32 a);
 	void setAlpha(const F32 alpha)					{ mColor.mV[VALPHA] = alpha; }
-	void setNormal(const LLVector3 &normal)		{ sNormal = normal; sNormal.normVec();}
+	void setNormal(const LLVector3 &normal)		{ sNormal = normal; sNormal.normalize();}
 
 	F32 getAlpha();
 
diff --git a/indra/newview/llviewermenu.cpp b/indra/newview/llviewermenu.cpp
index 2f8f5a29c5..26d526c988 100644
--- a/indra/newview/llviewermenu.cpp
+++ b/indra/newview/llviewermenu.cpp
@@ -2346,37 +2346,71 @@ class LLAvatarDebug : public view_listener_t
 	}
 };
 
+struct MenuCallbackData
+{
+	bool ban_enabled;
+	LLUUID avatar_id;
+};
+
 void callback_eject(S32 option, void* data)
 {
-	LLUUID* avatar_id = (LLUUID*) data;
+	MenuCallbackData *callback_data = (MenuCallbackData*)data;
+	if (!callback_data)
+	{
+		return;
+	}
+	if (2 == option)
+	{
+		// Cancle button.
+		return;
+	}
+	LLUUID avatar_id = callback_data->avatar_id;
+	bool ban_enabled = callback_data->ban_enabled;
 
-	if (0 == option || 1 == option)
+	if (0 == option)
 	{
+		// Eject button
 		LLMessageSystem* msg = gMessageSystem;
-		LLViewerObject* avatar = gObjectList.findObject(*avatar_id);
+		LLViewerObject* avatar = gObjectList.findObject(avatar_id);
 
 		if (avatar)
 		{
 			U32 flags = 0x0;
-			if (1 == option)
-			{
-				// eject and add to ban list
-				flags |= 0x1;
-			}
+			msg->newMessage("EjectUser");
+			msg->nextBlock("AgentData");
+			msg->addUUID("AgentID", gAgent.getID() );
+			msg->addUUID("SessionID", gAgent.getSessionID() );
+			msg->nextBlock("Data");
+			msg->addUUID("TargetID", avatar_id );
+			msg->addU32("Flags", flags );
+			msg->sendReliable( avatar->getRegion()->getHost() );
+		}
+	}
+	else if (ban_enabled)
+	{
+		// This is tricky. It is similar to say if it is not an 'Eject' button,
+		// and it is also not an 'Cancle' button, and ban_enabled==ture, 
+		// it should be the 'Eject and Ban' button.
+		LLMessageSystem* msg = gMessageSystem;
+		LLViewerObject* avatar = gObjectList.findObject(avatar_id);
 
+		if (avatar)
+		{
+			U32 flags = 0x1;
 			msg->newMessage("EjectUser");
 			msg->nextBlock("AgentData");
 			msg->addUUID("AgentID", gAgent.getID() );
 			msg->addUUID("SessionID", gAgent.getSessionID() );
 			msg->nextBlock("Data");
-			msg->addUUID("TargetID", *avatar_id );
+			msg->addUUID("TargetID", avatar_id );
 			msg->addU32("Flags", flags );
 			msg->sendReliable( avatar->getRegion()->getHost() );
 		}
 	}
 
-	delete avatar_id;
-	avatar_id = NULL;
+
+	delete callback_data;
+	callback_data = NULL;
 }
 
 class LLAvatarEject : public view_listener_t
@@ -2386,23 +2420,50 @@ class LLAvatarEject : public view_listener_t
 		LLVOAvatar* avatar = find_avatar_from_object( LLSelectMgr::getInstance()->getSelection()->getFirstObject() );
 		if( avatar )
 		{
-			LLUUID* avatar_id = new LLUUID( avatar->getID() );
+			MenuCallbackData *data = new MenuCallbackData;
+			(*data).avatar_id = avatar->getID();
 			std::string fullname = avatar->getFullname();
 
-			if (!fullname.empty())
+			const LLVector3d& pos = avatar->getPositionGlobal();
+			LLParcel* parcel = LLViewerParcelMgr::getInstance()->selectParcelAt(pos)->getParcel();
+			
+			if (LLViewerParcelMgr::getInstance()->isParcelOwnedByAgent(parcel,GP_LAND_MANAGE_BANNED))
 			{
-				LLStringUtil::format_map_t args;
-				args["[AVATAR_NAME]"] = fullname;
-				gViewerWindow->alertXml("EjectAvatarFullname",
-							args,
-							callback_eject,
-							(void*)avatar_id);
+				(*data).ban_enabled = true;
+				if (!fullname.empty())
+				{
+					LLStringUtil::format_map_t args;
+					args["[AVATAR_NAME]"] = fullname;
+					gViewerWindow->alertXml("EjectAvatarFullname",
+						args,
+						callback_eject,
+						(void*)data);
+				}
+				else
+				{
+					gViewerWindow->alertXml("EjectAvatar",
+						callback_eject,
+						(void*)data);
+				}
 			}
 			else
 			{
-				gViewerWindow->alertXml("EjectAvatar",
-							callback_eject,
-							(void*)avatar_id);
+				(*data).ban_enabled = false;
+				if (!fullname.empty())
+				{
+					LLStringUtil::format_map_t args;
+					args["[AVATAR_NAME]"] = fullname;
+					gViewerWindow->alertXml("EjectAvatarFullnameNoBan",
+						args,
+						callback_eject,
+						(void*)data);
+				}
+				else
+				{
+					gViewerWindow->alertXml("EjectAvatarNoBan",
+						callback_eject,
+						(void*)data);
+				}
 			}
 		}
 		return true;
@@ -2419,12 +2480,18 @@ class LLAvatarEnableFreezeEject : public view_listener_t
 		if (new_value)
 		{
 			const LLVector3& pos = avatar->getPositionRegion();
+			const LLVector3d& pos_global = avatar->getPositionGlobal();
+			LLParcel* parcel = LLViewerParcelMgr::getInstance()->selectParcelAt(pos_global)->getParcel();
 			LLViewerRegion* region = avatar->getRegion();
 			new_value = (region != NULL);
-
+						
 			if (new_value)
 			{
-				new_value = (region->isOwnedSelf(pos) || region->isOwnedGroup(pos));
+				new_value = region->isOwnedSelf(pos);
+				if (!new_value || region->isOwnedGroup(pos))
+				{
+					new_value = LLViewerParcelMgr::getInstance()->isParcelOwnedByAgent(parcel,GP_LAND_ADMIN);
+				}
 			}
 		}
 
diff --git a/indra/newview/llviewermenufile.cpp b/indra/newview/llviewermenufile.cpp
index b27d33b0e6..27badfb1dd 100644
--- a/indra/newview/llviewermenufile.cpp
+++ b/indra/newview/llviewermenufile.cpp
@@ -503,7 +503,7 @@ void handle_compress_image(void*)
 			}
 			else
 			{
-				llinfos << "Compression failed: " << LLImageBase::getLastError() << llendl;
+				llinfos << "Compression failed: " << LLImage::getLastError() << llendl;
 			}
 
 			infile = picker.getNextFile();
@@ -554,9 +554,9 @@ void upload_new_resource(const std::string& src_filename, std::string name,
 												 IMG_CODEC_BMP ))
 		{
 			error_message = llformat( "Problem with file %s:\n\n%s\n",
-					src_filename.c_str(), LLImageBase::getLastError().c_str());
+					 src_filename.c_str(), LLImage::getLastError().c_str());
 			args["[FILE]"] = src_filename;
-			args["[ERROR]"] = LLImageBase::getLastError();
+			args["[ERROR]"] = LLImage::getLastError();
 			upload_error(error_message, "ProblemWithFile", filename, args);
 			return;
 		}
@@ -569,9 +569,9 @@ void upload_new_resource(const std::string& src_filename, std::string name,
 												 IMG_CODEC_TGA ))
 		{
 			error_message = llformat("Problem with file %s:\n\n%s\n",
-					src_filename.c_str(), LLImageBase::getLastError().c_str());
+					src_filename.c_str(), LLImage::getLastError().c_str());
 			args["[FILE]"] = src_filename;
-			args["[ERROR]"] = LLImageBase::getLastError();
+			args["[ERROR]"] = LLImage::getLastError();
 			upload_error(error_message, "ProblemWithFile", filename, args);
 			return;
 		}
@@ -584,9 +584,9 @@ void upload_new_resource(const std::string& src_filename, std::string name,
 												 IMG_CODEC_JPEG ))
 		{
 			error_message = llformat("Problem with file %s:\n\n%s\n",
-					src_filename.c_str(), LLImageBase::getLastError().c_str());
+					src_filename.c_str(), LLImage::getLastError().c_str());
 			args["[FILE]"] = src_filename;
-			args["[ERROR]"] = LLImageBase::getLastError();
+			args["[ERROR]"] = LLImage::getLastError();
 			upload_error(error_message, "ProblemWithFile", filename, args);
 			return;
 		}
@@ -599,9 +599,9 @@ void upload_new_resource(const std::string& src_filename, std::string name,
  												 IMG_CODEC_PNG ))
  		{
  			error_message = llformat("Problem with file %s:\n\n%s\n",
- 					src_filename.c_str(), LLImageBase::getLastError().c_str());
+ 					src_filename.c_str(), LLImage::getLastError().c_str());
  			args["[FILE]"] = src_filename;
- 			args["[ERROR]"] = LLImageBase::getLastError();
+ 			args["[ERROR]"] = LLImage::getLastError();
  			upload_error(error_message, "ProblemWithFile", filename, args);
  			return;
  		}
diff --git a/indra/newview/llviewerregion.cpp b/indra/newview/llviewerregion.cpp
index b22ca7d2e9..f8c7b317f0 100644
--- a/indra/newview/llviewerregion.cpp
+++ b/indra/newview/llviewerregion.cpp
@@ -1389,6 +1389,7 @@ void LLViewerRegion::setSeedCapability(const std::string& url)
 	capabilityNames.append("EventQueueGet");
 	capabilityNames.append("FetchInventoryDescendents");
 	capabilityNames.append("GroupProposalBallot");
+	capabilityNames.append("HomeLocation");
 	capabilityNames.append("MapLayer");
 	capabilityNames.append("MapLayerGod");
 	capabilityNames.append("NewFileAgentInventory");
diff --git a/indra/newview/llvoavatar.cpp b/indra/newview/llvoavatar.cpp
index e9440dc9cb..d5d7056ef7 100644
--- a/indra/newview/llvoavatar.cpp
+++ b/indra/newview/llvoavatar.cpp
@@ -1131,7 +1131,7 @@ void LLVOAvatar::dumpBakedStatus()
 		}
 
 
-		F64 dist_to_camera = (inst->getPositionGlobal() - camera_pos_global).magVec();
+		F64 dist_to_camera = (inst->getPositionGlobal() - camera_pos_global).length();
 		llcont << " " << dist_to_camera << "m ";
 
 		llcont << " " << inst->mPixelArea << " pixels";
@@ -2684,8 +2684,8 @@ void LLVOAvatar::idleUpdateMisc(bool detailed_update)
 			else
 			{
 				getSpatialExtents(ext[0], ext[1]);
-				if ((ext[1]-mImpostorExtents[1]).magVec() > 0.05f ||
-					(ext[0]-mImpostorExtents[0]).magVec() > 0.05f)
+				if ((ext[1]-mImpostorExtents[1]).length() > 0.05f ||
+					(ext[0]-mImpostorExtents[0]).length() > 0.05f)
 				{
 					mNeedsImpostorUpdate = TRUE;
 				}
@@ -2852,7 +2852,7 @@ void LLVOAvatar::idleUpdateWindEffect()
 		F32 time_delta = mRippleTimer.getElapsedTimeF32() - mRippleTimeLast;
 		mRippleTimeLast = mRippleTimer.getElapsedTimeF32();
 		LLVector3 velocity = getVelocity();
-		F32 speed = velocity.magVec();
+		F32 speed = velocity.length();
 		//RN: velocity varies too much frame to frame for this to work
 		mRippleAccel.clearVec();//lerp(mRippleAccel, (velocity - mLastVel) * time_delta, LLCriticalDamp::getInterpolant(0.02f));
 		mLastVel = velocity;
@@ -2871,7 +2871,7 @@ void LLVOAvatar::idleUpdateWindEffect()
 		}
 
 		wind.mV[VZ] += hover_strength;
-		wind.normVec();
+		wind.normalize();
 
 		wind.mV[VW] = llmin(0.025f + (speed * 0.015f) + hover_strength, 0.5f);
 		F32 interp;
@@ -2994,10 +2994,10 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
 				LLVector3 pixel_up_vec;
 				LLViewerCamera::getInstance()->getPixelVectors(root_pos_last, pixel_up_vec, pixel_right_vec);
 				LLVector3 camera_to_av = root_pos_last - LLViewerCamera::getInstance()->getOrigin();
-				camera_to_av.normVec();
+				camera_to_av.normalize();
 				LLVector3 local_camera_at = camera_to_av * ~root_rot;
 				LLVector3 local_camera_up = camera_to_av % LLViewerCamera::getInstance()->getLeftAxis();
-				local_camera_up.normVec();
+				local_camera_up.normalize();
 				local_camera_up = local_camera_up * ~root_rot;
 			
 				local_camera_up.scaleVec(mBodySize * 0.5f);
@@ -3456,7 +3456,7 @@ BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
 
 	LLVector3 xyVel = getVelocity();
 	xyVel.mV[VZ] = 0.0f;
-	speed = xyVel.magVec();
+	speed = xyVel.length();
 
 	BOOL throttle = TRUE;
 
@@ -3541,14 +3541,14 @@ BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
 			if (mIsSelf)
 			{
 				primDir = agent.getAtAxis() - projected_vec(agent.getAtAxis(), agent.getReferenceUpVector());
-				primDir.normVec();
+				primDir.normalize();
 			}
 			else
 			{
 				primDir = getRotation().getMatrix3().getFwdRow();
 			}
 			LLVector3 velDir = getVelocity();
-			velDir.normVec();
+			velDir.normalize();
 			if ( mSignaledAnimations.find(ANIM_AGENT_WALK) != mSignaledAnimations.end())
 			{
 				F32 vpD = velDir * primDir;
@@ -3570,13 +3570,13 @@ BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
 					LLVector3 at_axis = LLViewerCamera::getInstance()->getAtAxis();
 					LLVector3 up_vector = gAgent.getReferenceUpVector();
 					at_axis -= up_vector * (at_axis * up_vector);
-					at_axis.normVec();
+					at_axis.normalize();
 					
 					F32 dot = fwdDir * at_axis;
 					if (dot < 0.f)
 					{
 						fwdDir -= 2.f * at_axis * dot;
-						fwdDir.normVec();
+						fwdDir.normalize();
 					}
 				}
 				
@@ -3644,7 +3644,7 @@ BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
 
 			// Now compute the full world space rotation for the whole body (wQv)
 			LLVector3 leftDir = upDir % fwdDir;
-			leftDir.normVec();
+			leftDir.normalize();
 			fwdDir = leftDir % upDir;
 			LLQuaternion wQv( fwdDir, leftDir, upDir );
 
@@ -4253,7 +4253,7 @@ U32 LLVOAvatar::renderImpostor(LLColor4U color)
 
 	LLVector3 pos(getRenderPosition()+mImpostorOffset);
 	LLVector3 at = (pos - LLViewerCamera::getInstance()->getOrigin());
-	at.normVec();
+	at.normalize();
 	LLVector3 left = LLViewerCamera::getInstance()->getUpAxis() % at;
 	LLVector3 up = at%left;
 
@@ -5784,7 +5784,7 @@ void LLVOAvatar::setPixelAreaAndAngle(LLAgent &agent)
 	}
 	else
 	{
-		F32 radius = size.magVec();
+		F32 radius = size.length();
 		mAppAngle = (F32) atan2( radius, range) * RAD_TO_DEG;
 	}
 
@@ -5953,7 +5953,7 @@ void LLVOAvatar::updateShadowFaces()
 			sprite.setPosition(shadow_pos_agent);
 
 			LLVector3 foot_to_knee = mKneeLeftp->getWorldPosition() - joint_world_pos;
-			//foot_to_knee.normVec();
+			//foot_to_knee.normalize();
 			foot_to_knee -= projected_vec(foot_to_knee, sun_vec);
 			sprite.setYaw(azimuth(sun_vec - foot_to_knee));
 		
@@ -5986,7 +5986,7 @@ void LLVOAvatar::updateShadowFaces()
 			sprite.setPosition(shadow_pos_agent);
 
 			LLVector3 foot_to_knee = mKneeRightp->getWorldPosition() - joint_world_pos;
-			//foot_to_knee.normVec();
+			//foot_to_knee.normalize();
 			foot_to_knee -= projected_vec(foot_to_knee, sun_vec);
 			sprite.setYaw(azimuth(sun_vec - foot_to_knee));
 	
@@ -6355,7 +6355,7 @@ void LLVOAvatar::getOffObject()
 		LLVector3 at_axis = LLVector3::x_axis;
 		at_axis = at_axis * av_rot;
 		at_axis.mV[VZ] = 0.f;
-		at_axis.normVec();
+		at_axis.normalize();
 		gAgent.resetAxes(at_axis);
 
 		//reset orientation
@@ -9861,7 +9861,7 @@ void LLVOAvatar::getImpostorValues(LLVector3* extents, LLVector3& angle, F32& di
 	extents[1] = ext[1];
 
 	LLVector3 at = LLViewerCamera::getInstance()->getOrigin()-(getRenderPosition()+mImpostorOffset);
-	distance = at.normVec();
+	distance = at.normalize();
 	F32 da = 1.f - (at*LLViewerCamera::getInstance()->getAtAxis());
 	angle.mV[0] = LLViewerCamera::getInstance()->getYaw()*da;
 	angle.mV[1] = LLViewerCamera::getInstance()->getPitch()*da;
diff --git a/indra/newview/llvograss.cpp b/indra/newview/llvograss.cpp
index cc7d73e37a..c7326688a0 100644
--- a/indra/newview/llvograss.cpp
+++ b/indra/newview/llvograss.cpp
@@ -273,9 +273,9 @@ U32 LLVOGrass::processUpdateMessage(LLMessageSystem *mesgsys,
 
 	updateSpecies();
 
-	if (  (getVelocity().magVecSquared() > 0.f)
-		||(getAcceleration().magVecSquared() > 0.f)
-		||(getAngularVelocity().magVecSquared() > 0.f))
+	if (  (getVelocity().lengthSquared() > 0.f)
+		||(getAcceleration().lengthSquared() > 0.f)
+		||(getAngularVelocity().lengthSquared() > 0.f))
 	{
 		llinfos << "ACK! Moving grass!" << llendl;
 		setVelocity(LLVector3::zero);
@@ -322,7 +322,7 @@ void LLVOGrass::setPixelAreaAndAngle(LLAgent &agent)
 {
 	// This should be the camera's center, as soon as we move to all region-local.
 	LLVector3 relative_position = getPositionAgent() - agent.getCameraPositionAgent();
-	F32 range = relative_position.magVec();
+	F32 range = relative_position.length();
 
 	F32 max_scale = getMaxScale();
 
@@ -501,7 +501,7 @@ void LLVOGrass::getGeometry(S32 idx,
 
 		LLVector3 normal1 = (v1-v2) % (v2-v3);
 		normal1.mV[VZ] = 0.75f;
-		normal1.normVec();
+		normal1.normalize();
 		LLVector3 normal2 = -normal1;
 		normal2.mV[VZ] = -normal2.mV[VZ];
 
diff --git a/indra/newview/llvopartgroup.cpp b/indra/newview/llvopartgroup.cpp
index 6cc61e36e0..3724a94edd 100644
--- a/indra/newview/llvopartgroup.cpp
+++ b/indra/newview/llvopartgroup.cpp
@@ -95,7 +95,7 @@ void LLVOPartGroup::setPixelAreaAndAngle(LLAgent &agent)
 {
 	// mPixelArea is calculated during render
 	F32 mid_scale = getMidScale();
-	F32 range = (getRenderPosition()-LLViewerCamera::getInstance()->getOrigin()).magVec();
+	F32 range = (getRenderPosition()-LLViewerCamera::getInstance()->getOrigin()).length();
 
 	if (range < 0.001f || isHUDAttachment())		// range == zero
 	{
@@ -189,7 +189,7 @@ BOOL LLVOPartGroup::updateGeometry(LLDrawable *drawable)
 		LLVector3 part_pos_agent(part->mPosAgent);
 		at = part_pos_agent - camera_agent;
 
-		F32 camera_dist_squared = at.magVecSquared();
+		F32 camera_dist_squared = at.lengthSquared();
 		F32 inv_camera_dist_squared;
 		if (camera_dist_squared > 1.f)
 			inv_camera_dist_squared = 1.f / camera_dist_squared;
@@ -283,26 +283,26 @@ void LLVOPartGroup::getGeometry(S32 idx,
 	LLVector3 up, right;
 
 	right = at % LLVector3(0.f, 0.f, 1.f);
-	right.normVec();
+	right.normalize();
 	up = right % at;
-	up.normVec();
+	up.normalize();
 
 	if (part.mFlags & LLPartData::LL_PART_FOLLOW_VELOCITY_MASK)
 	{
 		LLVector3 normvel = part.mVelocity;
-		normvel.normVec();
+		normvel.normalize();
 		LLVector2 up_fracs;
 		up_fracs.mV[0] = normvel*right;
 		up_fracs.mV[1] = normvel*up;
-		up_fracs.normVec();
+		up_fracs.normalize();
 		LLVector3 new_up;
 		LLVector3 new_right;
 		new_up = up_fracs.mV[0] * right + up_fracs.mV[1]*up;
 		new_right = up_fracs.mV[1] * right - up_fracs.mV[0]*up;
 		up = new_up;
 		right = new_right;
-		up.normVec();
-		right.normVec();
+		up.normalize();
+		right.normalize();
 	}
 
 	right *= 0.5f*part.mScale.mV[0];
diff --git a/indra/newview/llvosky.cpp b/indra/newview/llvosky.cpp
index 330d5c370d..e619ca1754 100644
--- a/indra/newview/llvosky.cpp
+++ b/indra/newview/llvosky.cpp
@@ -528,7 +528,7 @@ void LLVOSky::initSkyTextureDirs(const S32 side, const S32 tile)
 			coeff[x_coef] = F32((x<<1) + 1) * inv_res - 1.f;
 			coeff[y_coef] = F32((y<<1) + 1) * inv_res - 1.f;
 			LLVector3 dir(coeff[0], coeff[1], coeff[2]);
-			dir.normVec();
+			dir.normalize();
 			mSkyTex[side].setDir(dir, x, y);
 			mShinyTex[side].setDir(dir, x, y);
 		}
@@ -762,7 +762,7 @@ void LLVOSky::calcSkyColorWLVert(LLVector3 & Pn, LLColor3 & vary_HazeColor, LLCo
 		Pn *= (-32000.f / Pn[1]);
 	}
 
-	Plen = Pn.magVec();
+	Plen = Pn.length();
 	Pn /= Plen;
 
 	// Initialize temp variables
@@ -1082,7 +1082,7 @@ BOOL LLVOSky::updateSky()
 			const static F32 COLOR_CHANGE_THRESHOLD = 0.01f;
 
 			LLVector3 direction = mSun.getDirection();
-			direction.normVec();
+			direction.normalize();
 			const F32 dot_lighting = direction * mLastLightingDirection;
 
 			LLColor3 delta_color;
@@ -1092,7 +1092,7 @@ BOOL LLVOSky::updateSky()
 
 			if ( mForceUpdate 
 				 || ((dot_lighting < LIGHT_DIRECTION_THRESHOLD)
-				 || (delta_color.magVec() > COLOR_CHANGE_THRESHOLD)
+				 || (delta_color.length() > COLOR_CHANGE_THRESHOLD)
 				 || !mInitialized)
 				&& !direction.isExactlyZero())
 			{
@@ -1336,8 +1336,8 @@ BOOL LLVOSky::updateGeometry(LLDrawable *drawable)
 	const LLVector3 &look_at = LLViewerCamera::getInstance()->getAtAxis();
 	LLVector3 right = look_at % LLVector3::z_axis;
 	LLVector3 up = right % look_at;
-	right.normVec();
-	up.normVec();
+	right.normalize();
+	up.normalize();
 
 	const static F32 elevation_factor = 0.0f/sResolution;
 	const F32 cos_max_angle = cosHorizon(elevation_factor);
@@ -1417,8 +1417,8 @@ BOOL LLVOSky::updateHeavenlyBodyGeometry(LLDrawable *drawable, const S32 f, cons
 
 	LLVector3 hb_right = to_dir % LLVector3::z_axis;
 	LLVector3 hb_up = hb_right % to_dir;
-	hb_right.normVec();
-	hb_up.normVec();
+	hb_right.normalize();
+	hb_up.normalize();
 
 	//const static F32 cos_max_turn = sqrt(3.f) / 2; // 30 degrees
 	//const F32 cos_turn_right = 1. / (llmax(cos_max_turn, hb_right * right));
@@ -1601,8 +1601,8 @@ void LLVOSky::updateSunHaloGeometry(LLDrawable *drawable )
 
 	const LLVector3 right = 2 * (v_corner[2] - v_corner[0]);
 	LLVector3 up = 2 * (v_corner[2] - v_corner[3]);
-	up.normVec();
-	F32 size = right.magVec();
+	up.normalize();
+	F32 size = right.length();
 	up = size * up;
 	const LLVector3 draw_pos = 0.25 * (v_corner[0] + v_corner[1] + v_corner[2] + v_corner[3]);
 	
@@ -1654,7 +1654,7 @@ void LLVOSky::updateSunHaloGeometry(LLDrawable *drawable )
 F32 dtReflection(const LLVector3& p, F32 cos_dir_from_top, F32 sin_dir_from_top, F32 diff_angl_dir)
 {
 	LLVector3 P = p;
-	P.normVec();
+	P.normalize();
 
 	const F32 cos_dir_angle = -P.mV[VZ];
 	const F32 sin_dir_angle = sqrt(1 - cos_dir_angle * cos_dir_angle);
@@ -1679,9 +1679,9 @@ F32 dtClip(const LLVector3& v0, const LLVector3& v1, F32 far_clip2)
 {
 	F32 dt_clip;
 	const LLVector3 otrezok = v1 - v0;
-	const F32 A = otrezok.magVecSquared();
+	const F32 A = otrezok.lengthSquared();
 	const F32 B = v0 * otrezok;
-	const F32 C = v0.magVecSquared() - far_clip2;
+	const F32 C = v0.lengthSquared() - far_clip2;
 	const F32 det = sqrt(B*B - A*C);
 	dt_clip = (-B - det) / A;
 	if ((dt_clip < 0) || (dt_clip > 1))
@@ -1701,16 +1701,16 @@ void LLVOSky::updateReflectionGeometry(LLDrawable *drawable, F32 H,
 	LLVector3 hb_pos = to_dir * (HORIZON_DIST - 10);
 	LLVector3 to_dir_proj = to_dir;
 	to_dir_proj.mV[VZ] = 0;
-	to_dir_proj.normVec();
+	to_dir_proj.normalize();
 
 	LLVector3 Right = to_dir % LLVector3::z_axis;
 	LLVector3 Up = Right % to_dir;
-	Right.normVec();
-	Up.normVec();
+	Right.normalize();
+	Up.normalize();
 
 	// finding angle between  look direction and sprite.
 	LLVector3 look_at_right = look_at % LLVector3::z_axis;
-	look_at_right.normVec();
+	look_at_right.normalize();
 
 	const static F32 cos_horizon_angle = cosHorizon(0.0f/sResolution);
 	//const static F32 horizon_angle = acos(cos_horizon_angle);
@@ -1745,7 +1745,7 @@ void LLVOSky::updateReflectionGeometry(LLDrawable *drawable, F32 H,
 	else
 		dt_hor = llmax(0.0f, llmin(1.0f, dt_hor));
 
-	top_hb.normVec();
+	top_hb.normalize();
 	const F32 cos_angle_of_view = fabs(top_hb.mV[VZ]);
 	const F32 extension = llmin (5.0f, 1.0f / cos_angle_of_view);
 
@@ -1762,11 +1762,11 @@ void LLVOSky::updateReflectionGeometry(LLDrawable *drawable, F32 H,
 	F32 cos_dir_from_top[2];
 
 	LLVector3 dir = stretch_corner[0];
-	dir.normVec();
+	dir.normalize();
 	cos_dir_from_top[0] = dir.mV[VZ];
 
 	dir = stretch_corner[1];
-	dir.normVec();
+	dir.normalize();
 	cos_dir_from_top[1] = dir.mV[VZ];
 
 	const F32 sin_dir_from_top = sqrt(1 - cos_dir_from_top[0] * cos_dir_from_top[0]);
@@ -1789,7 +1789,7 @@ void LLVOSky::updateReflectionGeometry(LLDrawable *drawable, F32 H,
 	for (vtx = 0; vtx < 2; ++vtx)
 	{
 		LLVector3 light_proj = v_corner[vtx];
-		light_proj.normVec();
+		light_proj.normalize();
 
 		const F32 z = light_proj.mV[VZ];
 		const F32 sin_angle = sqrt(1 - z * z);
@@ -1813,9 +1813,9 @@ void LLVOSky::updateReflectionGeometry(LLDrawable *drawable, F32 H,
 	S32 side = 0;
 	LLVector3 refl_corn_norm[2];
 	refl_corn_norm[0] = v_refl_corner[1];
-	refl_corn_norm[0].normVec();
+	refl_corn_norm[0].normalize();
 	refl_corn_norm[1] = v_refl_corner[3];
-	refl_corn_norm[1].normVec();
+	refl_corn_norm[1].normalize();
 
 	F32 cos_refl_look_at[2];
 	cos_refl_look_at[0] = refl_corn_norm[0] * look_at;
@@ -1833,13 +1833,13 @@ void LLVOSky::updateReflectionGeometry(LLDrawable *drawable, F32 H,
 	F32 dt_clip;
 	F32 vtx_near2, vtx_far2;
 
-	if ((vtx_far2 = v_refl_corner[side].magVecSquared()) > far_clip2)
+	if ((vtx_far2 = v_refl_corner[side].lengthSquared()) > far_clip2)
 	{
 		// whole thing is sprite: reflection is beyond far clip plane.
 		dt_clip = 1.1f;
 		quads = 1;
 	}
-	else if ((vtx_near2 = v_refl_corner[side+1].magVecSquared()) > far_clip2)
+	else if ((vtx_near2 = v_refl_corner[side+1].lengthSquared()) > far_clip2)
 	{
 		// part is reflection, the rest is sprite.
 		dt_clip = dtClip(v_refl_corner[side + 1], v_refl_corner[side], far_clip2);
@@ -1903,7 +1903,7 @@ void LLVOSky::updateReflectionGeometry(LLDrawable *drawable, F32 H,
 		{
 			for (S32 vtx = 0; vtx < 4; ++vtx)
 			{
-				F32 ratio = far_clip / v_refl_corner[vtx].magVec();
+				F32 ratio = far_clip / v_refl_corner[vtx].length();
 				*(verticesp++) = v_refl_corner[vtx] = ratio * v_refl_corner[vtx] + mCameraPosAgent;
 			}
 			const LLVector3 draw_pos = 0.25 *
@@ -1912,10 +1912,10 @@ void LLVOSky::updateReflectionGeometry(LLDrawable *drawable, F32 H,
 		}
 		else
 		{
-			F32 ratio = far_clip / v_refl_corner[1].magVec();
+			F32 ratio = far_clip / v_refl_corner[1].length();
 			v_sprite_corner[1] = v_refl_corner[1] * ratio;
 
-			ratio = far_clip / v_refl_corner[3].magVec();
+			ratio = far_clip / v_refl_corner[3].length();
 			v_sprite_corner[3] = v_refl_corner[3] * ratio;
 
 			v_refl_corner[1] = (1 - dt_clip) * v_refl_corner[1] + dt_clip * v_refl_corner[0];
@@ -2039,20 +2039,20 @@ void LLVOSky::updateFog(const F32 distance)
 	LLVector3 tosun = getToSunLast();
 	const F32 tosun_z = tosun.mV[VZ];
 	tosun.mV[VZ] = 0.f;
-	tosun.normVec();
+	tosun.normalize();
 	LLVector3 perp_tosun;
 	perp_tosun.mV[VX] = -tosun.mV[VY];
 	perp_tosun.mV[VY] = tosun.mV[VX];
 	LLVector3 tosun_45 = tosun + perp_tosun;
-	tosun_45.normVec();
+	tosun_45.normalize();
 
 	F32 delta = 0.06f;
 	tosun.mV[VZ] = delta;
 	perp_tosun.mV[VZ] = delta;
 	tosun_45.mV[VZ] = delta;
-	tosun.normVec();
-	perp_tosun.normVec();
-	tosun_45.normVec();
+	tosun.normalize();
+	perp_tosun.normalize();
+	tosun_45.normalize();
 
 	// Sky colors, just slightly above the horizon in the direction of the sun, perpendicular to the sun, and at a 45 degree angle to the sun.
 	initAtmospherics();
@@ -2202,8 +2202,8 @@ F32 azimuth(const LLVector3 &v)
 
 void LLVOSky::initSunDirection(const LLVector3 &sun_dir, const LLVector3 &sun_ang_velocity)
 {
-	LLVector3 sun_direction = (sun_dir.magVec() == 0) ? LLVector3::x_axis : sun_dir;
-	sun_direction.normVec();
+	LLVector3 sun_direction = (sun_dir.length() == 0) ? LLVector3::x_axis : sun_dir;
+	sun_direction.normalize();
 	mSun.setDirection(sun_direction);
 	mSun.renewDirection();
 	mSun.setAngularVelocity(sun_ang_velocity);
@@ -2222,8 +2222,8 @@ void LLVOSky::initSunDirection(const LLVector3 &sun_dir, const LLVector3 &sun_an
 
 void LLVOSky::setSunDirection(const LLVector3 &sun_dir, const LLVector3 &sun_ang_velocity)
 {
-	LLVector3 sun_direction = (sun_dir.magVec() == 0) ? LLVector3::x_axis : sun_dir;
-	sun_direction.normVec();
+	LLVector3 sun_direction = (sun_dir.length() == 0) ? LLVector3::x_axis : sun_dir;
+	sun_direction.normalize();
 
 	// Push the sun "South" as it approaches directly overhead so that we can always see bump mapping
 	// on the upward facing faces of cubes.
@@ -2239,7 +2239,7 @@ void LLVOSky::setSunDirection(const LLVector3 &sun_dir, const LLVector3 &sun_ang
 	// Blend between normal sun dir and adjusted sun dir based on how close we are
 	// to having the sun overhead.
 	mBumpSunDir = adjustedDir * sunDot + newDir * (1.0f - sunDot);
-	mBumpSunDir.normVec();
+	mBumpSunDir.normalize();
 
 	F32 dp = mLastLightingDirection * sun_direction;
 	mSun.setDirection(sun_direction);
diff --git a/indra/newview/llvotextbubble.cpp b/indra/newview/llvotextbubble.cpp
index b48a5a989c..952c3c9a87 100644
--- a/indra/newview/llvotextbubble.cpp
+++ b/indra/newview/llvotextbubble.cpp
@@ -126,7 +126,7 @@ void LLVOTextBubble::updateTextures(LLAgent &agent)
 
 	LLVector3 position_local = getPositionAgent() - agent.getCameraPositionAgent();
 	F32 dot_product = position_local * agent.getFrameAgent().getAtAxis();
-	F32 cos_angle = dot_product / position_local.magVec();
+	F32 cos_angle = dot_product / position_local.length();
 
 	if (cos_angle > 1.f)
 	{
diff --git a/indra/newview/llvotree.cpp b/indra/newview/llvotree.cpp
index 97a1ed162d..0c9b524f7f 100644
--- a/indra/newview/llvotree.cpp
+++ b/indra/newview/llvotree.cpp
@@ -273,9 +273,9 @@ U32 LLVOTree::processUpdateMessage(LLMessageSystem *mesgsys,
 	// Do base class updates...
 	U32 retval = LLViewerObject::processUpdateMessage(mesgsys, user_data, block_num, update_type, dp);
 
-	if (  (getVelocity().magVecSquared() > 0.f)
-		||(getAcceleration().magVecSquared() > 0.f)
-		||(getAngularVelocity().magVecSquared() > 0.f))
+	if (  (getVelocity().lengthSquared() > 0.f)
+		||(getAcceleration().lengthSquared() > 0.f)
+		||(getAngularVelocity().lengthSquared() > 0.f))
 	{
 		llinfos << "ACK! Moving tree!" << llendl;
 		setVelocity(LLVector3::zero);
@@ -359,14 +359,14 @@ BOOL LLVOTree::idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time)
 	mTrunkBend += mTrunkVel;
 	mTrunkVel *= 0.99f;									//  Add damping
 
-	if (mTrunkBend.magVec() > 1.f)
+	if (mTrunkBend.length() > 1.f)
 	{
-		mTrunkBend.normVec();
+		mTrunkBend.normalize();
 	}
 
-	if (mTrunkVel.magVec() > 1.f)
+	if (mTrunkVel.length() > 1.f)
 	{
-		mTrunkVel.normVec();
+		mTrunkVel.normalize();
 	}
 
 	return TRUE;
@@ -391,7 +391,7 @@ void LLVOTree::setPixelAreaAndAngle(LLAgent &agent)
 	
 	// This should be the camera's center, as soon as we move to all region-local.
 	LLVector3 relative_position = getPositionAgent() - agent.getCameraPositionAgent();
-	F32 range = relative_position.magVec();				// ugh, square root
+	F32 range = relative_position.length();				// ugh, square root
 
 	F32 max_scale = mBillboardScale * getMaxScale();
 	F32 area = max_scale * (max_scale*mBillboardRatio);
@@ -713,9 +713,9 @@ BOOL LLVOTree::updateGeometry(LLDrawable *drawable)
 				LLVector2 tc;
 				// This isn't totally accurate.  Should compute based on slope as well.
 				start_radius = r0 * (1.f + 1.2f*fabs(z - 0.66f*height)/height);
-				nvec.setVec(	cos(nangle * DEG_TO_RAD)*start_radius*nvec_scale, 
-								sin(nangle * DEG_TO_RAD)*start_radius*nvec_scale, 
-								z*nvec_scalez); 
+				nvec.set(	cos(nangle * DEG_TO_RAD)*start_radius*nvec_scale, 
+							sin(nangle * DEG_TO_RAD)*start_radius*nvec_scale, 
+							z*nvec_scalez); 
 				// First and last slice at 0 radius (to bring in top/bottom of structure)
 				radius = start_radius + turbulence3((F32*)&nvec.mV, (F32)fractal_depth)*noise_scale;
 
@@ -918,7 +918,7 @@ void LLVOTree::updateRadius()
 
 void LLVOTree::updateSpatialExtents(LLVector3& newMin, LLVector3& newMax)
 {
-	F32 radius = getScale().magVec()*0.05f;
+	F32 radius = getScale().length()*0.05f;
 	LLVector3 center = getRenderPosition();
 
 	F32 sz = mBillboardScale*mBillboardRatio*radius*0.5f; 
@@ -926,8 +926,8 @@ void LLVOTree::updateSpatialExtents(LLVector3& newMin, LLVector3& newMax)
 
 	center += LLVector3(0, 0, size.mV[2]) * getRotation();
 	
-	newMin.setVec(center-size);
-	newMax.setVec(center+size);
+	newMin.set(center-size);
+	newMax.set(center+size);
 	mDrawable->setPositionGroup(center);
 }
 
diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index 225d9a18b2..c6a7e9e28d 100644
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -89,7 +89,7 @@ LLVOVolume::LLVOVolume(const LLUUID &id, const LLPCode pcode, LLViewerRegion *re
 	mLOD = MIN_LOD;
 	mSculptLevel = -2;
 	mTextureAnimp = NULL;
-	mVObjRadius = LLVector3(1,1,0.5f).magVec();
+	mVObjRadius = LLVector3(1,1,0.5f).length();
 	mNumFaces = 0;
 	mLODChanged = FALSE;
 	mSculptChanged = FALSE;
@@ -570,7 +570,7 @@ F32 LLVOVolume::getTextureVirtualSize(LLFace* face)
 
 	//get area of circle in texture space
 	LLVector2 tdim = face->mTexExtents[1] - face->mTexExtents[0];
-	F32 texel_area = (tdim * 0.5f).magVecSquared()*3.14159f;
+	F32 texel_area = (tdim * 0.5f).lengthSquared()*3.14159f;
 	if (texel_area <= 0)
 	{
 		// Probably animated, use default
@@ -821,7 +821,7 @@ BOOL LLVOVolume::calcLOD()
 
 	S32 cur_detail = 0;
 	
-	F32 radius = getVolume()->mLODScaleBias.scaledVec(getScale()).magVec();
+	F32 radius = getVolume()->mLODScaleBias.scaledVec(getScale()).length();
 	F32 distance = mDrawable->mDistanceWRTCamera;
 	distance *= sDistanceFactor;
 			
@@ -1680,7 +1680,7 @@ void LLVOVolume::generateSilhouette(LLSelectNode* nodep, const LLVector3& view_p
 
 		//transform view vector into volume space
 		view_vector -= getRenderPosition();
-		mDrawable->mDistanceWRTCamera = view_vector.magVec();
+		mDrawable->mDistanceWRTCamera = view_vector.length();
 		LLQuaternion worldRot = getRenderRotation();
 		view_vector = view_vector * ~worldRot;
 		if (!isVolumeGlobal())
@@ -1721,7 +1721,7 @@ void LLVOVolume::updateRadius()
 		return;
 	}
 	
-	mVObjRadius = getScale().magVec();
+	mVObjRadius = getScale().length();
 	mDrawable->setRadius(mVObjRadius);
 }
 
@@ -1834,7 +1834,7 @@ F32 LLVOVolume::getBinRadius()
 	}
 	else if (shrink_wrap)
 	{
-		radius = (ext[1]-ext[0]).magVec()*0.5f;
+		radius = (ext[1]-ext[0]).length()*0.5f;
 	}
 	else if (mDrawable->isStatic())
 	{
@@ -1956,13 +1956,13 @@ BOOL LLVOVolume::lineSegmentIntersect(const LLVector3& start, const LLVector3& e
 			if (normal != NULL)
 			{
 				*normal = volumeDirectionToAgent(*normal);
-				(*normal).normVec();
+				(*normal).normalize();
 			}
 
 			if (bi_normal != NULL)
 			{
 				*bi_normal = volumeDirectionToAgent(*bi_normal);
-				(*bi_normal).normVec();
+				(*bi_normal).normalize();
 			}
 
 			
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index b9facb28b2..f3168be46c 100644
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -3089,7 +3089,7 @@ void LLPipeline::setupAvatarLights(BOOL for_edit)
 		camera_rot.invert();
 		LLVector4 light_pos = light_pos_cam * camera_rot;
 		
-		light_pos.normVec();
+		light_pos.normalize();
 
 		mHWLightColors[1] = diffuse;
 		glLightfv(GL_LIGHT1, GL_DIFFUSE,  diffuse.mV);
@@ -3107,7 +3107,7 @@ void LLPipeline::setupAvatarLights(BOOL for_edit)
 		LLVector3 opposite_pos = -1.f * mSunDir;
 		LLVector3 orthog_light_pos = mSunDir % LLVector3::z_axis;
 		LLVector4 backlight_pos = LLVector4(lerp(opposite_pos, orthog_light_pos, 0.3f), 0.0f);
-		backlight_pos.normVec();
+		backlight_pos.normalize();
 			
 		LLColor4 light_diffuse = mSunDiffuse;
 		LLColor4 backlight_diffuse(1.f - light_diffuse.mV[VRED], 1.f - light_diffuse.mV[VGREEN], 1.f - light_diffuse.mV[VBLUE], 1.f);
@@ -5172,11 +5172,11 @@ void LLPipeline::generateImpostor(LLVOAvatar* avatar)
 
 	LLVector3 left = camera.getLeftAxis();
 	left *= left;
-	left.normVec();
+	left.normalize();
 
 	LLVector3 up = camera.getUpAxis();
 	up *= up;
-	up.normVec();
+	up.normalize();
 
 	tdim.mV[0] = fabsf(half_height * left);
 	tdim.mV[1] = fabsf(half_height * up);