Merge branch 'master' into DRTVWR-530-maint

209 files changed, 3553 insertions, 4879 deletions

diff --git a/indra/CMakeLists.txt b/indra/CMakeLists.txt
index bc2ee2e6cd..dc1c28ce5b 100644
--- a/indra/CMakeLists.txt
+++ b/indra/CMakeLists.txt
@@ -41,7 +41,7 @@ add_subdirectory(${LIBS_OPEN_PREFIX}llmath)
 add_subdirectory(${LIBS_OPEN_PREFIX}llmessage)
 add_subdirectory(${LIBS_OPEN_PREFIX}llprimitive)
 add_subdirectory(${LIBS_OPEN_PREFIX}llrender)
-add_subdirectory(${LIBS_OPEN_PREFIX}llvfs)
+add_subdirectory(${LIBS_OPEN_PREFIX}llfilesystem)
 add_subdirectory(${LIBS_OPEN_PREFIX}llwindow)
 add_subdirectory(${LIBS_OPEN_PREFIX}llxml)
 
diff --git a/indra/cmake/00-Common.cmake b/indra/cmake/00-Common.cmake
index 8aea50e02b..f4071793d5 100644
--- a/indra/cmake/00-Common.cmake
+++ b/indra/cmake/00-Common.cmake
@@ -66,11 +66,10 @@ if (WINDOWS)
   # CP changed to only append the flag for 32bit builds - on 64bit builds,
   # locally at least, the build output is spammed with 1000s of 'D9002'
   # warnings about this switch being ignored.
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")  
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
   if( ADDRESS_SIZE EQUAL 32 )
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /p:PreferredToolArchitecture=x64")  
   endif()
-
   set(CMAKE_CXX_FLAGS_RELWITHDEBINFO 
       "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /Zo"
       CACHE STRING "C++ compiler release-with-debug options" FORCE)
diff --git a/indra/cmake/CMakeLists.txt b/indra/cmake/CMakeLists.txt
index cca305c741..d7725670a2 100644
--- a/indra/cmake/CMakeLists.txt
+++ b/indra/cmake/CMakeLists.txt
@@ -67,7 +67,7 @@ set(cmake_SOURCE_FILES
     LLSharedLibs.cmake
     LLTestCommand.cmake
     LLUI.cmake
-    LLVFS.cmake
+    LLFileSystem.cmake
     LLWindow.cmake
     LLXML.cmake
     Linking.cmake
diff --git a/indra/cmake/CubemapToEquirectangularJS.cmake b/indra/cmake/CubemapToEquirectangularJS.cmake
new file mode 100644
index 0000000000..bfe2926005
--- /dev/null
+++ b/indra/cmake/CubemapToEquirectangularJS.cmake
@@ -0,0 +1,5 @@
+# -*- cmake -*-
+use_prebuilt_binary(cubemaptoequirectangular)
+
+# Main JS file
+configure_file("${AUTOBUILD_INSTALL_DIR}/js/CubemapToEquirectangular.js" "${CMAKE_SOURCE_DIR}/newview/skins/default/html/common/equirectangular/js/CubemapToEquirectangular.js" COPYONLY)
diff --git a/indra/cmake/JPEGEncoderBasic.cmake b/indra/cmake/JPEGEncoderBasic.cmake
new file mode 100644
index 0000000000..0d2a3231bb
--- /dev/null
+++ b/indra/cmake/JPEGEncoderBasic.cmake
@@ -0,0 +1,5 @@
+# -*- cmake -*-
+use_prebuilt_binary(jpegencoderbasic)
+
+# Main JS file
+configure_file("${AUTOBUILD_INSTALL_DIR}/js/jpeg_encoder_basic.js" "${CMAKE_SOURCE_DIR}/newview/skins/default/html/common/equirectangular/js/jpeg_encoder_basic.js" COPYONLY)
diff --git a/indra/cmake/LLFileSystem.cmake b/indra/cmake/LLFileSystem.cmake
new file mode 100644
index 0000000000..2e6c42c30c
--- /dev/null
+++ b/indra/cmake/LLFileSystem.cmake
@@ -0,0 +1,7 @@
+# -*- cmake -*-
+
+set(LLFILESYSTEM_INCLUDE_DIRS
+    ${LIBS_OPEN_DIR}/llfilesystem
+    )
+
+set(LLFILESYSTEM_LIBRARIES llfilesystem)
diff --git a/indra/cmake/LLVFS.cmake b/indra/cmake/LLVFS.cmake
deleted file mode 100644
index 0fe87cdea6..0000000000
--- a/indra/cmake/LLVFS.cmake
+++ /dev/null
@@ -1,7 +0,0 @@
-# -*- cmake -*-
-
-set(LLVFS_INCLUDE_DIRS
-    ${LIBS_OPEN_DIR}/llvfs
-    )
-
-set(LLVFS_LIBRARIES llvfs)
diff --git a/indra/cmake/ThreeJS.cmake b/indra/cmake/ThreeJS.cmake
new file mode 100644
index 0000000000..528adcbb25
--- /dev/null
+++ b/indra/cmake/ThreeJS.cmake
@@ -0,0 +1,8 @@
+# -*- cmake -*-
+use_prebuilt_binary(threejs)
+
+# Main three.js file
+configure_file("${AUTOBUILD_INSTALL_DIR}/js/three.min.js" "${CMAKE_SOURCE_DIR}/newview/skins/default/html/common/equirectangular/js/three.min.js" COPYONLY)
+
+# Controls to move around the scene using mouse or keyboard
+configure_file("${AUTOBUILD_INSTALL_DIR}/js/OrbitControls.js" "${CMAKE_SOURCE_DIR}/newview/skins/default/html/common/equirectangular/js/OrbitControls.js" COPYONLY)
diff --git a/indra/integration_tests/llimage_libtest/CMakeLists.txt b/indra/integration_tests/llimage_libtest/CMakeLists.txt
index 5787d4d600..bd59f57e49 100644
--- a/indra/integration_tests/llimage_libtest/CMakeLists.txt
+++ b/indra/integration_tests/llimage_libtest/CMakeLists.txt
@@ -10,11 +10,11 @@ include(LLImage)
 include(LLMath)
 include(LLImageJ2COJ) 
 include(LLKDU)
-include(LLVFS)
+include(LLFileSystem)
 
 include_directories(
     ${LLCOMMON_INCLUDE_DIRS}
-    ${LLVFS_INCLUDE_DIRS}
+    ${LLFILESYSTEM_INCLUDE_DIRS}
     ${LLIMAGE_INCLUDE_DIRS}
     ${LLMATH_INCLUDE_DIRS}
     )
@@ -66,7 +66,7 @@ endif (DARWIN)
 target_link_libraries(llimage_libtest
     ${LEGACY_STDIO_LIBS}
     ${LLCOMMON_LIBRARIES}
-    ${LLVFS_LIBRARIES}
+    ${LLFILESYSTEM_LIBRARIES}
     ${LLMATH_LIBRARIES}
     ${LLIMAGE_LIBRARIES}
     ${LLKDU_LIBRARIES}
diff --git a/indra/integration_tests/llui_libtest/CMakeLists.txt b/indra/integration_tests/llui_libtest/CMakeLists.txt
index 1cec660eb0..d7706e73b2 100644
--- a/indra/integration_tests/llui_libtest/CMakeLists.txt
+++ b/indra/integration_tests/llui_libtest/CMakeLists.txt
@@ -16,7 +16,7 @@ include(LLMessage)
 include(LLRender)
 include(LLWindow)
 include(LLUI)
-include(LLVFS)        # ugh, needed for LLDir
+include(LLFileSystem)
 include(LLXML)
 include(Hunspell)
 include(Linking)
@@ -29,7 +29,7 @@ include_directories(
     ${LLMATH_INCLUDE_DIRS}
     ${LLRENDER_INCLUDE_DIRS}
     ${LLUI_INCLUDE_DIRS}
-    ${LLVFS_INCLUDE_DIRS}
+    ${LLFILESYSTEM_INCLUDE_DIRS}
     ${LLWINDOW_INCLUDE_DIRS}
     ${LLXML_INCLUDE_DIRS}
     ${LIBS_PREBUILD_DIR}/include/hunspell
diff --git a/indra/linux_crash_logger/CMakeLists.txt b/indra/linux_crash_logger/CMakeLists.txt
index d789c850a0..aa82ed12cc 100644
--- a/indra/linux_crash_logger/CMakeLists.txt
+++ b/indra/linux_crash_logger/CMakeLists.txt
@@ -9,7 +9,7 @@ include(LLCommon)
 include(LLCrashLogger)
 include(LLMath)
 include(LLMessage)
-include(LLVFS)
+include(LLFileSystem)
 include(LLXML)
 include(Linking)
 include(UI)
@@ -21,7 +21,7 @@ include_directories(
     ${LLCOMMON_INCLUDE_DIRS}
     ${LLCRASHLOGGER_INCLUDE_DIRS}
     ${LLMATH_INCLUDE_DIRS}
-    ${LLVFS_INCLUDE_DIRS}
+    ${LLFILESYSTEM_INCLUDE_DIRS}
     ${LLXML_INCLUDE_DIRS}
     ${FREETYPE_INCLUDE_DIRS}
     )
@@ -62,10 +62,9 @@ set(LIBRT_LIBRARY rt)
 
 target_link_libraries(linux-crash-logger
     ${LLCRASHLOGGER_LIBRARIES}
-    ${LLVFS_LIBRARIES}
+    ${LLFILESYSTEM_LIBRARIES}
     ${LLXML_LIBRARIES}
     ${LLMESSAGE_LIBRARIES}
-    ${LLVFS_LIBRARIES}
     ${LLMATH_LIBRARIES}
     ${LLCOREHTTP_LIBRARIES}
     ${LLCOMMON_LIBRARIES}
diff --git a/indra/llappearance/CMakeLists.txt b/indra/llappearance/CMakeLists.txt
index 20eb4678dd..268849ad74 100644
--- a/indra/llappearance/CMakeLists.txt
+++ b/indra/llappearance/CMakeLists.txt
@@ -11,7 +11,7 @@ include(LLMath)
 include(LLMessage)
 include(LLCoreHttp)
 include(LLRender)
-include(LLVFS)
+include(LLFileSystem)
 include(LLWindow)
 include(LLXML)
 include(Linking)
@@ -23,7 +23,7 @@ include_directories(
     ${LLINVENTORY_INCLUDE_DIRS}
     ${LLMATH_INCLUDE_DIRS}
     ${LLRENDER_INCLUDE_DIRS}
-    ${LLVFS_INCLUDE_DIRS}
+    ${LLFILESYSTEM_INCLUDE_DIRS}
     ${LLWINDOW_INCLUDE_DIRS}
     ${LLXML_INCLUDE_DIRS}
     )
@@ -83,7 +83,7 @@ target_link_libraries(llappearance
     ${LLINVENTORY_LIBRARIES}
     ${LLIMAGE_LIBRARIES}
     ${LLRENDER_LIBRARIES}
-    ${LLVFS_LIBRARIES}
+    ${LLFILESYSTEM_LIBRARIES}
     ${LLMATH_LIBRARIES}
     ${LLXML_LIBRARIES}
     ${LLMATH_LIBRARIES}
@@ -100,7 +100,7 @@ if (BUILD_HEADLESS)
       ${LLINVENTORY_LIBRARIES}
       ${LLIMAGE_LIBRARIES}
       ${LLRENDERHEADLESS_LIBRARIES}
-      ${LLVFS_LIBRARIES}
+      ${LLFILESYSTEM_LIBRARIES}
       ${LLMATH_LIBRARIES}
       ${LLXML_LIBRARIES}
       ${LLMATH_LIBRARIES}
@@ -109,15 +109,3 @@ if (BUILD_HEADLESS)
       ${LLCOMMON_LIBRARIES}
       )
 endif (BUILD_HEADLESS)
-
-#add unit tests
-#if (LL_TESTS)
-#    INCLUDE(LLAddBuildTest)
-#    SET(llappearance_TEST_SOURCE_FILES
-#      # no real unit tests yet!
-#      )
-#    LL_ADD_PROJECT_UNIT_TESTS(llappearance "${llappearance_TEST_SOURCE_FILES}")
-
-    #set(TEST_DEBUG on)
-#    set(test_libs llappearance ${LLCOMMON_LIBRARIES})
-#endif (LL_TESTS)
diff --git a/indra/llappearance/lltexlayer.cpp b/indra/llappearance/lltexlayer.cpp
index e5039141de..a4600069ce 100644
--- a/indra/llappearance/lltexlayer.cpp
+++ b/indra/llappearance/lltexlayer.cpp
@@ -33,8 +33,6 @@
 #include "llimagej2c.h"
 #include "llimagetga.h"
 #include "lldir.h"
-#include "llvfile.h"
-#include "llvfs.h"
 #include "lltexlayerparams.h"
 #include "lltexturemanagerbridge.h"
 #include "lllocaltextureobject.h"
diff --git a/indra/llaudio/CMakeLists.txt b/indra/llaudio/CMakeLists.txt
index 558ede7bf6..92a5cfe22f 100644
--- a/indra/llaudio/CMakeLists.txt
+++ b/indra/llaudio/CMakeLists.txt
@@ -9,14 +9,14 @@ include(OPENAL)
 include(LLCommon)
 include(LLMath)
 include(LLMessage)
-include(LLVFS)
+include(LLFileSystem)
 
 include_directories(
     ${LLAUDIO_INCLUDE_DIRS}
     ${LLCOMMON_INCLUDE_DIRS}
     ${LLMATH_INCLUDE_DIRS}
     ${LLMESSAGE_INCLUDE_DIRS}
-    ${LLVFS_INCLUDE_DIRS}
+    ${LLFILESYSTEM_INCLUDE_DIRS}
     ${OGG_INCLUDE_DIRS}
     ${VORBISENC_INCLUDE_DIRS}
     ${VORBISFILE_INCLUDE_DIRS}
@@ -86,7 +86,7 @@ target_link_libraries(
     ${LLCOMMON_LIBRARIES}
     ${LLMATH_LIBRARIES}
     ${LLMESSAGE_LIBRARIES}
-    ${LLVFS_LIBRARIES}
+    ${LLFILESYSTEM_LIBRARIES}
     ${VORBISENC_LIBRARIES}
     ${VORBISFILE_LIBRARIES}
     ${VORBIS_LIBRARIES}
diff --git a/indra/llaudio/llaudiodecodemgr.cpp b/indra/llaudio/llaudiodecodemgr.cpp
index e7db84f6ab..ff0aa6e76e 100644
--- a/indra/llaudio/llaudiodecodemgr.cpp
+++ b/indra/llaudio/llaudiodecodemgr.cpp
@@ -29,7 +29,7 @@
 
 #include "llaudioengine.h"
 #include "lllfsthread.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
 #include "llstring.h"
 #include "lldir.h"
 #include "llendianswizzle.h"
@@ -90,19 +90,17 @@ protected:
 	LLUUID mUUID;
 
 	std::vector<U8> mWAVBuffer;
-#if !defined(USE_WAV_VFILE)
 	std::string mOutFilename;
 	LLLFSThread::handle_t mFileHandle;
-#endif
 	
-	LLVFile *mInFilep;
+	LLFileSystem *mInFilep;
 	OggVorbis_File mVF;
 	S32 mCurrentSection;
 };
 
-size_t vfs_read(void *ptr, size_t size, size_t nmemb, void *datasource)
+size_t cache_read(void *ptr, size_t size, size_t nmemb, void *datasource)
 {
-	LLVFile *file = (LLVFile *)datasource;
+	LLFileSystem *file = (LLFileSystem *)datasource;
 
 	if (file->read((U8*)ptr, (S32)(size * nmemb)))	/*Flawfinder: ignore*/
 	{
@@ -115,11 +113,11 @@ size_t vfs_read(void *ptr, size_t size, size_t nmemb, void *datasource)
 	}
 }
 
-S32 vfs_seek(void *datasource, ogg_int64_t offset, S32 whence)
+S32 cache_seek(void *datasource, ogg_int64_t offset, S32 whence)
 {
-	LLVFile *file = (LLVFile *)datasource;
+	LLFileSystem *file = (LLFileSystem *)datasource;
 
-	// vfs has 31-bit files
+	// cache has 31-bit files
 	if (offset > S32_MAX)
 	{
 		return -1;
@@ -137,7 +135,7 @@ S32 vfs_seek(void *datasource, ogg_int64_t offset, S32 whence)
 		origin = -1;
 		break;
 	default:
-		LL_ERRS("AudioEngine") << "Invalid whence argument to vfs_seek" << LL_ENDL;
+		LL_ERRS("AudioEngine") << "Invalid whence argument to cache_seek" << LL_ENDL;
 		return -1;
 	}
 
@@ -151,16 +149,16 @@ S32 vfs_seek(void *datasource, ogg_int64_t offset, S32 whence)
 	}
 }
 
-S32 vfs_close (void *datasource)
+S32 cache_close (void *datasource)
 {
-	LLVFile *file = (LLVFile *)datasource;
+	LLFileSystem *file = (LLFileSystem *)datasource;
 	delete file;
 	return 0;
 }
 
-long vfs_tell (void *datasource)
+long cache_tell (void *datasource)
 {
-	LLVFile *file = (LLVFile *)datasource;
+	LLFileSystem *file = (LLFileSystem *)datasource;
 	return file->tell();
 }
 
@@ -172,11 +170,10 @@ LLVorbisDecodeState::LLVorbisDecodeState(const LLUUID &uuid, const std::string &
 	mUUID = uuid;
 	mInFilep = NULL;
 	mCurrentSection = 0;
-#if !defined(USE_WAV_VFILE)
 	mOutFilename = out_filename;
 	mFileHandle = LLLFSThread::nullHandle();
-#endif
-	// No default value for mVF, it's an ogg structure?
+
+    // No default value for mVF, it's an ogg structure?
 	// Hey, let's zero it anyway, for predictability.
 	memset(&mVF, 0, sizeof(mVF));
 }
@@ -193,15 +190,15 @@ LLVorbisDecodeState::~LLVorbisDecodeState()
 
 BOOL LLVorbisDecodeState::initDecode()
 {
-	ov_callbacks vfs_callbacks;
-	vfs_callbacks.read_func = vfs_read;
-	vfs_callbacks.seek_func = vfs_seek;
-	vfs_callbacks.close_func = vfs_close;
-	vfs_callbacks.tell_func = vfs_tell;
+	ov_callbacks cache_callbacks;
+	cache_callbacks.read_func = cache_read;
+	cache_callbacks.seek_func = cache_seek;
+	cache_callbacks.close_func = cache_close;
+	cache_callbacks.tell_func = cache_tell;
 
 	LL_DEBUGS("AudioEngine") << "Initing decode from vfile: " << mUUID << LL_ENDL;
 
-	mInFilep = new LLVFile(gVFS, mUUID, LLAssetType::AT_SOUND);
+	mInFilep = new LLFileSystem(mUUID, LLAssetType::AT_SOUND);
 	if (!mInFilep || !mInFilep->getSize())
 	{
 		LL_WARNS("AudioEngine") << "unable to open vorbis source vfile for reading" << LL_ENDL;
@@ -210,7 +207,7 @@ BOOL LLVorbisDecodeState::initDecode()
 		return FALSE;
 	}
 
-	S32 r = ov_open_callbacks(mInFilep, &mVF, NULL, 0, vfs_callbacks);
+	S32 r = ov_open_callbacks(mInFilep, &mVF, NULL, 0, cache_callbacks);
 	if(r < 0) 
 	{
 		LL_WARNS("AudioEngine") << r << " Input to vorbis decode does not appear to be an Ogg bitstream: " << mUUID << LL_ENDL;
@@ -370,7 +367,7 @@ BOOL LLVorbisDecodeState::decodeSection()
 {
 	if (!mInFilep)
 	{
-		LL_WARNS("AudioEngine") << "No VFS file to decode in vorbis!" << LL_ENDL;
+		LL_WARNS("AudioEngine") << "No cache file to decode in vorbis!" << LL_ENDL;
 		return TRUE;
 	}
 	if (mDone)
@@ -420,9 +417,7 @@ BOOL LLVorbisDecodeState::finishDecode()
 		return TRUE; // We've finished
 	}
 
-#if !defined(USE_WAV_VFILE)	
 	if (mFileHandle == LLLFSThread::nullHandle())
-#endif
 	{
 		ov_clear(&mVF);
   
@@ -495,11 +490,9 @@ BOOL LLVorbisDecodeState::finishDecode()
 			mValid = FALSE;
 			return TRUE; // we've finished
 		}
-#if !defined(USE_WAV_VFILE)
 		mBytesRead = -1;
 		mFileHandle = LLLFSThread::sLocal->write(mOutFilename, &mWAVBuffer[0], 0, mWAVBuffer.size(),
 							 new WriteResponder(this));
-#endif
 	}
 
 	if (mFileHandle != LLLFSThread::nullHandle())
@@ -521,11 +514,6 @@ BOOL LLVorbisDecodeState::finishDecode()
 	
 	mDone = TRUE;
 
-#if defined(USE_WAV_VFILE)
-	// write the data.
-	LLVFile output(gVFS, mUUID, LLAssetType::AT_SOUND_WAV);
-	output.write(&mWAVBuffer[0], mWAVBuffer.size());
-#endif
 	LL_DEBUGS("AudioEngine") << "Finished decode for " << getUUID() << LL_ENDL;
 
 	return TRUE;
@@ -535,7 +523,7 @@ void LLVorbisDecodeState::flushBadFile()
 {
 	if (mInFilep)
 	{
-		LL_WARNS("AudioEngine") << "Flushing bad vorbis file from VFS for " << mUUID << LL_ENDL;
+		LL_WARNS("AudioEngine") << "Flushing bad vorbis file from cache for " << mUUID << LL_ENDL;
 		mInFilep->remove();
 	}
 }
diff --git a/indra/llaudio/llaudiodecodemgr.h b/indra/llaudio/llaudiodecodemgr.h
index 8228e20e8c..ceaff3f2d8 100644
--- a/indra/llaudio/llaudiodecodemgr.h
+++ b/indra/llaudio/llaudiodecodemgr.h
@@ -33,7 +33,6 @@
 #include "llassettype.h"
 #include "llframetimer.h"
 
-class LLVFS;
 class LLVorbisDecodeState;
 
 class LLAudioDecodeMgr
diff --git a/indra/llaudio/llaudioengine.cpp b/indra/llaudio/llaudioengine.cpp
index 1d447f32ae..d35f249973 100644
--- a/indra/llaudio/llaudioengine.cpp
+++ b/indra/llaudio/llaudioengine.cpp
@@ -35,7 +35,7 @@
 
 #include "sound_ids.h"  // temporary hack for min/max distances
 
-#include "llvfs.h"
+#include "llfilesystem.h"
 #include "lldir.h"
 #include "llaudiodecodemgr.h"
 #include "llassetstorage.h"
@@ -684,13 +684,9 @@ bool LLAudioEngine::preloadSound(const LLUUID &uuid)
 		return true;
 	}
 
-	// At some point we need to have the audio/asset system check the static VFS
-	// before it goes off and fetches stuff from the server.
-	//LL_WARNS() << "Used internal preload for non-local sound" << LL_ENDL;
 	return false;
 }
 
-
 bool LLAudioEngine::isWindEnabled()
 {
 	return mEnableWind;
@@ -1018,13 +1014,12 @@ bool LLAudioEngine::hasDecodedFile(const LLUUID &uuid)
 
 bool LLAudioEngine::hasLocalFile(const LLUUID &uuid)
 {
-	// See if it's in the VFS.
-	bool have_local = gVFS->getExists(uuid, LLAssetType::AT_SOUND);
-	LL_DEBUGS("AudioEngine") << "sound uuid "<<uuid<<" exists in VFS"<<LL_ENDL;
+	// See if it's in the cache.
+	bool have_local = LLFileSystem::getExists(uuid, LLAssetType::AT_SOUND);
+	LL_DEBUGS("AudioEngine") << "sound uuid " << uuid << " exists in cache" << LL_ENDL;
 	return have_local;
 }
 
-
 void LLAudioEngine::startNextTransfer()
 {
 	//LL_INFOS() << "LLAudioEngine::startNextTransfer()" << LL_ENDL;
@@ -1225,7 +1220,7 @@ void LLAudioEngine::startNextTransfer()
 
 
 // static
-void LLAudioEngine::assetCallback(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type, void *user_data, S32 result_code, LLExtStat ext_status)
+void LLAudioEngine::assetCallback(const LLUUID &uuid, LLAssetType::EType type, void *user_data, S32 result_code, LLExtStat ext_status)
 {
 	if (!gAudiop)
 	{
diff --git a/indra/llaudio/llaudioengine.h b/indra/llaudio/llaudioengine.h
index 97674f15f7..577b36d667 100644
--- a/indra/llaudio/llaudioengine.h
+++ b/indra/llaudio/llaudioengine.h
@@ -50,15 +50,6 @@ const F32 DEFAULT_MIN_DISTANCE = 2.0f;
 #define MAX_CHANNELS 30
 #define MAX_BUFFERS 40	// Some extra for preloading, maybe?
 
-// This define is intended to allow us to switch from os based wav
-// file loading to vfs based wav file loading. The problem is that I
-// am unconvinced that the LLWaveFile works for loading sounds from
-// memory. So, until that is fixed up, changed, whatever, this remains
-// undefined.
-//#define USE_WAV_VFILE
-
-class LLVFS;
-
 class LLAudioSource;
 class LLAudioData;
 class LLAudioChannel;
@@ -67,11 +58,9 @@ class LLAudioBuffer;
 class LLStreamingAudioInterface;
 struct SoundData;
 
-
 //
 //  LLAudioEngine definition
 //
-
 class LLAudioEngine 
 {
 	friend class LLAudioChannelOpenAL; // bleh. channel needs some listener methods.
@@ -182,7 +171,7 @@ public:
 
 	// Asset callback when we're retrieved a sound from the asset server.
 	void startNextTransfer();
-	static void assetCallback(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type, void *user_data, S32 result_code, LLExtStat ext_status);
+	static void assetCallback(const LLUUID &uuid, LLAssetType::EType type, void *user_data, S32 result_code, LLExtStat ext_status);
 
 	friend class LLPipeline; // For debugging
 public:
diff --git a/indra/llcharacter/CMakeLists.txt b/indra/llcharacter/CMakeLists.txt
index a17a5b0aa6..d90ffb5543 100644
--- a/indra/llcharacter/CMakeLists.txt
+++ b/indra/llcharacter/CMakeLists.txt
@@ -6,14 +6,14 @@ include(00-Common)
 include(LLCommon)
 include(LLMath)
 include(LLMessage)
-include(LLVFS)
+include(LLFileSystem)
 include(LLXML)
 
 include_directories(
     ${LLCOMMON_INCLUDE_DIRS}
     ${LLMATH_INCLUDE_DIRS}
     ${LLMESSAGE_INCLUDE_DIRS}
-    ${LLVFS_INCLUDE_DIRS}
+    ${LLFILESYSTEM_INCLUDE_DIRS}
     ${LLXML_INCLUDE_DIRS}
     )
 include_directories(SYSTEM
@@ -85,18 +85,6 @@ target_link_libraries(
     ${LLCOMMON_LIBRARIES}
     ${LLMATH_LIBRARIES}
     ${LLMESSAGE_LIBRARIES}
-    ${LLVFS_LIBRARIES}
+    ${LLFILESYSTEM_LIBRARIES}
     ${LLXML_LIBRARIES}
     )
-
-
-# Add tests
-#if (LL_TESTS)
-#    include(LLAddBuildTest)
-#    # UNIT TESTS
-#    SET(llcharacter_TEST_SOURCE_FILES
-#      lljoint.cpp
-#      )
-#    LL_ADD_PROJECT_UNIT_TESTS(llcharacter "${llcharacter_TEST_SOURCE_FILES}")
-#endif (LL_TESTS)
-
diff --git a/indra/llcharacter/llkeyframefallmotion.cpp b/indra/llcharacter/llkeyframefallmotion.cpp
index 60ab2e9929..7842f0e5fb 100644
--- a/indra/llcharacter/llkeyframefallmotion.cpp
+++ b/indra/llcharacter/llkeyframefallmotion.cpp
@@ -70,6 +70,11 @@ LLMotion::LLMotionInitStatus LLKeyframeFallMotion::onInitialize(LLCharacter *cha
 	// load keyframe data, setup pose and joint states
 	LLMotion::LLMotionInitStatus result = LLKeyframeMotion::onInitialize(character);
 
+	if (result != LLMotion::STATUS_SUCCESS)
+	{
+		return result;
+	}
+
 	for (U32 jm=0; jm<mJointMotionList->getNumJointMotions(); jm++)
 	{
 		if (!mJointStates[jm]->getJoint())
diff --git a/indra/llcharacter/llkeyframemotion.cpp b/indra/llcharacter/llkeyframemotion.cpp
index cde38c8091..fe9de30f0a 100644
--- a/indra/llcharacter/llkeyframemotion.cpp
+++ b/indra/llcharacter/llkeyframemotion.cpp
@@ -39,14 +39,13 @@
 #include "llendianswizzle.h"
 #include "llkeyframemotion.h"
 #include "llquantize.h"
-#include "llvfile.h"
 #include "m3math.h"
 #include "message.h"
+#include "llfilesystem.h"
 
 //-----------------------------------------------------------------------------
 // Static Definitions
 //-----------------------------------------------------------------------------
-LLVFS*				LLKeyframeMotion::sVFS = NULL;
 LLKeyframeDataCache::keyframe_data_map_t	LLKeyframeDataCache::sKeyframeDataMap;
 
 //-----------------------------------------------------------------------------
@@ -515,7 +514,7 @@ LLMotion::LLMotionInitStatus LLKeyframeMotion::onInitialize(LLCharacter *charact
 		return STATUS_SUCCESS;
 	default:
 		// we don't know what state the asset is in yet, so keep going
-		// check keyframe cache first then static vfs then asset request
+		// check keyframe cache first then file cache then asset request
 		break;
 	}
 
@@ -559,13 +558,8 @@ LLMotion::LLMotionInitStatus LLKeyframeMotion::onInitialize(LLCharacter *charact
 	U8 *anim_data;
 	S32 anim_file_size;
 
-	if (!sVFS)
-	{
-		LL_ERRS() << "Must call LLKeyframeMotion::setVFS() first before loading a keyframe file!" << LL_ENDL;
-	}
-
 	BOOL success = FALSE;
-	LLVFile* anim_file = new LLVFile(sVFS, mID, LLAssetType::AT_ANIMATION);
+	LLFileSystem* anim_file = new LLFileSystem(mID, LLAssetType::AT_ANIMATION);
 	if (!anim_file || !anim_file->getSize())
 	{
 		delete anim_file;
@@ -2296,10 +2290,9 @@ void LLKeyframeMotion::setLoopOut(F32 out_point)
 //-----------------------------------------------------------------------------
 // onLoadComplete()
 //-----------------------------------------------------------------------------
-void LLKeyframeMotion::onLoadComplete(LLVFS *vfs,
-									   const LLUUID& asset_uuid,
-									   LLAssetType::EType type,
-									   void* user_data, S32 status, LLExtStat ext_status)
+void LLKeyframeMotion::onLoadComplete(const LLUUID& asset_uuid,
+									  LLAssetType::EType type,
+									  void* user_data, S32 status, LLExtStat ext_status)
 {
 	LLUUID* id = (LLUUID*)user_data;
 		
@@ -2331,7 +2324,7 @@ void LLKeyframeMotion::onLoadComplete(LLVFS *vfs,
 				// asset already loaded
 				return;
 			}
-			LLVFile file(vfs, asset_uuid, type, LLVFile::READ);
+			LLFileSystem file(asset_uuid, type, LLFileSystem::READ);
 			S32 size = file.getSize();
 			
 			U8* buffer = new U8[size];
diff --git a/indra/llcharacter/llkeyframemotion.h b/indra/llcharacter/llkeyframemotion.h
index 15c5c7c6c0..d640556090 100644
--- a/indra/llcharacter/llkeyframemotion.h
+++ b/indra/llcharacter/llkeyframemotion.h
@@ -44,7 +44,6 @@
 #include "llbvhconsts.h"
 
 class LLKeyframeDataCache;
-class LLVFS;
 class LLDataPacker;
 
 #define MIN_REQUIRED_PIXEL_AREA_KEYFRAME (40.f)
@@ -141,10 +140,7 @@ public:
 
 	virtual void setStopTime(F32 time);
 
-	static void setVFS(LLVFS* vfs) { sVFS = vfs; }
-
-	static void onLoadComplete(LLVFS *vfs,
-							   const LLUUID& asset_uuid,
+	static void onLoadComplete(const LLUUID& asset_uuid,
 							   LLAssetType::EType type,
 							   void* user_data, S32 status, LLExtStat ext_status);
 
@@ -416,13 +412,7 @@ public:
 		U32 getNumJointMotions() const { return mJointMotionArray.size(); }
 	};
 
-
 protected:
-	static LLVFS*				sVFS;
-
-	//-------------------------------------------------------------------------
-	// Member Data
-	//-------------------------------------------------------------------------
 	JointMotionList*				mJointMotionList;
 	std::vector<LLPointer<LLJointState> > mJointStates;
 	LLJoint*						mPelvisp;
diff --git a/indra/llcommon/llapp.cpp b/indra/llcommon/llapp.cpp
index df2a066f62..8ddd132793 100644
--- a/indra/llcommon/llapp.cpp
+++ b/indra/llcommon/llapp.cpp
@@ -106,7 +106,8 @@ BOOL LLApp::sDisableCrashlogger = FALSE;
 BOOL LLApp::sLogInSignal = FALSE;
 
 // static
-LLApp::EAppStatus LLApp::sStatus = LLApp::APP_STATUS_STOPPED; // Keeps track of application status
+// Keeps track of application status
+LLScalarCond<LLApp::EAppStatus> LLApp::sStatus{LLApp::APP_STATUS_STOPPED};
 LLAppErrorHandler LLApp::sErrorHandler = NULL;
 BOOL LLApp::sErrorThreadRunning = FALSE;
 
@@ -452,7 +453,8 @@ static std::map<LLApp::EAppStatus, const char*> statusDesc
 // static
 void LLApp::setStatus(EAppStatus status)
 {
-    sStatus = status;
+    // notify everyone waiting on sStatus any time its value changes
+    sStatus.set_all(status);
 
     // This can also happen very late in the application lifecycle -- don't
     // resurrect a deleted LLSingleton
@@ -514,28 +516,28 @@ void LLApp::setStopped()
 // static
 bool LLApp::isStopped()
 {
-	return (APP_STATUS_STOPPED == sStatus);
+	return (APP_STATUS_STOPPED == sStatus.get());
 }
 
 
 // static
 bool LLApp::isRunning()
 {
-	return (APP_STATUS_RUNNING == sStatus);
+	return (APP_STATUS_RUNNING == sStatus.get());
 }
 
 
 // static
 bool LLApp::isError()
 {
-	return (APP_STATUS_ERROR == sStatus);
+	return (APP_STATUS_ERROR == sStatus.get());
 }
 
 
 // static
 bool LLApp::isQuitting()
 {
-	return (APP_STATUS_QUITTING == sStatus);
+	return (APP_STATUS_QUITTING == sStatus.get());
 }
 
 // static
diff --git a/indra/llcommon/llapp.h b/indra/llcommon/llapp.h
index 83f3bf3f93..c65fe21c9c 100644
--- a/indra/llcommon/llapp.h
+++ b/indra/llcommon/llapp.h
@@ -28,9 +28,11 @@
 #define LL_LLAPP_H
 
 #include <map>
+#include "llcond.h"
 #include "llrun.h"
 #include "llsd.h"
 #include <atomic>
+#include <chrono>
 // Forward declarations
 class LLErrorThread;
 class LLLiveFile;
@@ -207,6 +209,36 @@ public:
 	static bool isExiting(); // Either quitting or error (app is exiting, cleanly or not)
 	static int getPid();
 
+	//
+	// Sleep for specified time while still running
+	//
+	// For use by a coroutine or thread that performs some maintenance on a
+	// periodic basis. (See also LLEventTimer.) This method supports the
+	// pattern of an "infinite" loop that sleeps for some time, performs some
+	// action, then sleeps again. The trouble with literally sleeping a worker
+	// thread is that it could potentially sleep right through attempted
+	// application shutdown. This method avoids that by returning false as
+	// soon as the application status changes away from APP_STATUS_RUNNING
+	// (isRunning()).
+	//
+	// sleep() returns true if it sleeps undisturbed for the entire specified
+	// duration. The idea is that you can code 'while sleep(duration) ...',
+	// which will break the loop once shutdown begins.
+	//
+	// Since any time-based LLUnit should be implicitly convertible to
+	// F32Milliseconds, accept that specific type as a proxy.
+	static bool sleep(F32Milliseconds duration);
+	// Allow any duration defined in terms of <chrono>.
+	// One can imagine a wonderfully general bidirectional conversion system
+	// between any type derived from LLUnits::LLUnit<T, LLUnits::Seconds> and
+	// any std::chrono::duration -- but that doesn't yet exist.
+	template <typename Rep, typename Period>
+	bool sleep(const std::chrono::duration<Rep, Period>& duration)
+	{
+		// wait_for_unequal() has the opposite bool return convention
+		return ! sStatus.wait_for_unequal(duration, APP_STATUS_RUNNING);
+	}
+
 	/** @name Error handling methods */
 	//@{
 	/**
@@ -236,8 +268,8 @@ public:
 
 	// Return the Google Breakpad minidump filename after a crash.
 	char *getMiniDumpFilename() { return mMinidumpPath; }
-    std::string* getStaticDebugFile() { return &mStaticDebugFileName; }
-    std::string* getDynamicDebugFile() { return &mDynamicDebugFileName; }
+	std::string* getStaticDebugFile() { return &mStaticDebugFileName; }
+	std::string* getDynamicDebugFile() { return &mDynamicDebugFileName; }
 
 	// Write out a Google Breakpad minidump file.
 	void writeMiniDump();
@@ -265,7 +297,7 @@ public:
 protected:
 
 	static void setStatus(EAppStatus status);		// Use this to change the application status.
-	static EAppStatus sStatus; // Reflects current application status
+	static LLScalarCond<EAppStatus> sStatus; // Reflects current application status
 	static BOOL sErrorThreadRunning; // Set while the error thread is running
 	static BOOL sDisableCrashlogger; // Let the OS handle crashes for us.
 	std::wstring mCrashReportPipeStr;  //Name of pipe to use for crash reporting.
diff --git a/indra/llcommon/llerror.cpp b/indra/llcommon/llerror.cpp
index 51b0fe8be8..3fe8ce5f0e 100644
--- a/indra/llcommon/llerror.cpp
+++ b/indra/llcommon/llerror.cpp
@@ -194,23 +194,64 @@ namespace {
         {
             return LLError::getEnabledLogTypesMask() & 0x04;
         }
-        
+
+        LL_FORCE_INLINE std::string createBoldANSI()
+        {
+            std::string ansi_code;
+            ansi_code += '\033';
+            ansi_code += "[";
+            ansi_code += "1";
+            ansi_code += "m";
+
+            return ansi_code;
+        }
+
+        LL_FORCE_INLINE std::string createResetANSI()
+        {
+            std::string ansi_code;
+            ansi_code += '\033';
+            ansi_code += "[";
+            ansi_code += "0";
+            ansi_code += "m";
+
+            return ansi_code;
+        }
+
         LL_FORCE_INLINE std::string createANSI(const std::string& color)
         {
             std::string ansi_code;
-            ansi_code  += '\033';
-            ansi_code  += "[";
-            ansi_code  += color;
+            ansi_code += '\033';
+            ansi_code += "[";
+            ansi_code += "38;5;";
+            ansi_code += color;
             ansi_code += "m";
+
             return ansi_code;
         }
 
 		virtual void recordMessage(LLError::ELevel level,
 					   const std::string& message) override
 		{
-            static std::string s_ansi_error = createANSI("31"); // red
-            static std::string s_ansi_warn  = createANSI("34"); // blue
-            static std::string s_ansi_debug = createANSI("35"); // magenta
+            // The default colors for error, warn and debug are now a bit more pastel
+            // and easier to read on the default (black) terminal background but you 
+            // now have the option to set the color of each via an environment variables:
+            // LL_ANSI_ERROR_COLOR_CODE (default is red)
+            // LL_ANSI_WARN_COLOR_CODE  (default is blue)
+            // LL_ANSI_DEBUG_COLOR_CODE (default is magenta)
+            // The list of color codes can be found in many places but I used this page:
+            // https://www.lihaoyi.com/post/BuildyourownCommandLinewithANSIescapecodes.html#256-colors
+            // (Note: you may need to restart Visual Studio to pick environment changes)
+            char* val = nullptr;
+            std::string s_ansi_error_code = "160";
+            if ((val = getenv("LL_ANSI_ERROR_COLOR_CODE")) != nullptr) s_ansi_error_code = std::string(val);
+            std::string s_ansi_warn_code = "33";
+            if ((val = getenv("LL_ANSI_WARN_COLOR_CODE")) != nullptr) s_ansi_warn_code = std::string(val);
+            std::string s_ansi_debug_code = "177";
+            if ((val = getenv("LL_ANSI_DEBUG_COLOR_CODE")) != nullptr) s_ansi_debug_code = std::string(val);
+
+            static std::string s_ansi_error = createANSI(s_ansi_error_code); // default is red
+            static std::string s_ansi_warn  = createANSI(s_ansi_warn_code); // default is blue
+            static std::string s_ansi_debug = createANSI(s_ansi_debug_code); // default is magenta
 
 			if (mUseANSI)
 			{
@@ -229,11 +270,11 @@ namespace {
 
         LL_FORCE_INLINE void writeANSI(const std::string& ansi_code, const std::string& message)
 		{
-            static std::string s_ansi_bold  = createANSI("1");  // bold
-            static std::string s_ansi_reset = createANSI("0");  // reset
+            static std::string s_ansi_bold = createBoldANSI();  // bold text
+            static std::string s_ansi_reset = createResetANSI();  // reset
 			// ANSI color code escape sequence, message, and reset in one fprintf call
             // Default all message levels to bold so we can distinguish our own messages from those dumped by subprocesses and libraries.
-			fprintf(stderr, "%s%s%s\n%s", s_ansi_bold.c_str(), ansi_code.c_str(), message.c_str(), s_ansi_reset.c_str() );
+			fprintf(stderr, "%s%s\n%s", ansi_code.c_str(), message.c_str(), s_ansi_reset.c_str() );
 		}
 
 		static bool checkANSI(void)
diff --git a/indra/llcommon/llthread.h b/indra/llcommon/llthread.h
index 5cd0731f6c..50202631e7 100644
--- a/indra/llcommon/llthread.h
+++ b/indra/llcommon/llthread.h
@@ -27,7 +27,6 @@
 #ifndef LL_LLTHREAD_H
 #define LL_LLTHREAD_H
 
-#include "llapp.h"
 #include "llapr.h"
 #include "boost/intrusive_ptr.hpp"
 #include "llrefcount.h"
diff --git a/indra/llcommon/lluuid.cpp b/indra/llcommon/lluuid.cpp
index e3b293e465..acce8366ea 100644
--- a/indra/llcommon/lluuid.cpp
+++ b/indra/llcommon/lluuid.cpp
@@ -33,6 +33,7 @@
 #include <iphlpapi.h>
 #endif
 
+#include "llapp.h"
 #include "lldefs.h"
 #include "llerror.h"
 
diff --git a/indra/llcrashlogger/CMakeLists.txt b/indra/llcrashlogger/CMakeLists.txt
index da23b46b7b..d70a1e0fb0 100644
--- a/indra/llcrashlogger/CMakeLists.txt
+++ b/indra/llcrashlogger/CMakeLists.txt
@@ -7,7 +7,7 @@ include(LLCoreHttp)
 include(LLCommon)
 include(LLMath)
 include(LLMessage)
-include(LLVFS)
+include(LLFileSystem)
 include(LLXML)
 
 include_directories(
@@ -15,7 +15,7 @@ include_directories(
     ${LLCOMMON_INCLUDE_DIRS}
     ${LLMATH_INCLUDE_DIRS}
     ${LLMESSAGE_INCLUDE_DIRS}
-    ${LLVFS_INCLUDE_DIRS}
+    ${LLFILESYSTEM_INCLUDE_DIRS}
     ${LLXML_INCLUDE_DIRS}
     )
 include_directories(SYSTEM
diff --git a/indra/llcrashlogger/llcrashlock.h b/indra/llcrashlogger/llcrashlock.h
index cde183272f..60b060b736 100644
--- a/indra/llcrashlogger/llcrashlock.h
+++ b/indra/llcrashlogger/llcrashlock.h
@@ -1,5 +1,5 @@
 /** 
- * @file llpidlock.h
+ * @file llcrashlock.h
  * @brief Maintainence of disk locking files for crash reporting
  *
  * $LicenseInfo:firstyear=2001&license=viewerlgpl$
diff --git a/indra/llcrashlogger/llcrashlogger.cpp b/indra/llcrashlogger/llcrashlogger.cpp
index e02f3a6306..0d8fb4863b 100644
--- a/indra/llcrashlogger/llcrashlogger.cpp
+++ b/indra/llcrashlogger/llcrashlogger.cpp
@@ -596,7 +596,7 @@ bool LLCrashLogger::init()
 #if LL_WINDOWS
 		Sleep(1000);
 #else
-        sleep(1);
+        ::sleep(1);
 #endif 
         locked = mKeyMaster.checkMaster();
     }
diff --git a/indra/llvfs/CMakeLists.txt b/indra/llfilesystem/CMakeLists.txt
index 67dce8c073..09c4c33ebf 100644
--- a/indra/llvfs/CMakeLists.txt
+++ b/indra/llfilesystem/CMakeLists.txt
@@ -1,6 +1,6 @@
 # -*- cmake -*-
 
-project(llvfs)
+project(llfilesystem)
 
 include(00-Common)
 include(LLCommon)
@@ -11,39 +11,34 @@ include_directories(
     ${LLCOMMON_SYSTEM_INCLUDE_DIRS}
     )
 
-set(llvfs_SOURCE_FILES
+set(llfilesystem_SOURCE_FILES
     lldir.cpp
     lldiriterator.cpp
     lllfsthread.cpp
-    llpidlock.cpp
-    llvfile.cpp
-    llvfs.cpp
-    llvfsthread.cpp
+    lldiskcache.cpp
+    llfilesystem.cpp
     )
 
-set(llvfs_HEADER_FILES
+set(llfilesystem_HEADER_FILES
     CMakeLists.txt
-
     lldir.h
     lldirguard.h
     lldiriterator.h
     lllfsthread.h
-    llpidlock.h
-    llvfile.h
-    llvfs.h
-    llvfsthread.h
+    lldiskcache.h
+    llfilesystem.h
     )
 
 if (DARWIN)
-  LIST(APPEND llvfs_SOURCE_FILES lldir_mac.cpp)
-  LIST(APPEND llvfs_HEADER_FILES lldir_mac.h)
-  LIST(APPEND llvfs_SOURCE_FILES llvfs_objc.mm)
-  LIST(APPEND llvfs_HEADER_FILES llvfs_objc.h)
+  LIST(APPEND llfilesystem_SOURCE_FILES lldir_utils_objc.mm)
+  LIST(APPEND llfilesystem_SOURCE_FILES lldir_utils_objc.h)
+  LIST(APPEND llfilesystem_SOURCE_FILES lldir_mac.cpp)
+  LIST(APPEND llfilesystem_HEADER_FILES lldir_mac.h)
 endif (DARWIN)
 
 if (LINUX)
-  LIST(APPEND llvfs_SOURCE_FILES lldir_linux.cpp)
-  LIST(APPEND llvfs_HEADER_FILES lldir_linux.h)
+  LIST(APPEND llfilesystem_SOURCE_FILES lldir_linux.cpp)
+  LIST(APPEND llfilesystem_HEADER_FILES lldir_linux.h)
 
   if (INSTALL)
     set_source_files_properties(lldir_linux.cpp
@@ -54,31 +49,31 @@ if (LINUX)
 endif (LINUX)
 
 if (WINDOWS)
-  LIST(APPEND llvfs_SOURCE_FILES lldir_win32.cpp)
-  LIST(APPEND llvfs_HEADER_FILES lldir_win32.h)
+  LIST(APPEND llfilesystem_SOURCE_FILES lldir_win32.cpp)
+  LIST(APPEND llfilesystem_HEADER_FILES lldir_win32.h)
 endif (WINDOWS)
 
-set_source_files_properties(${llvfs_HEADER_FILES}
+set_source_files_properties(${llfilesystem_HEADER_FILES}
                             PROPERTIES HEADER_FILE_ONLY TRUE)
 
-list(APPEND llvfs_SOURCE_FILES ${llvfs_HEADER_FILES})
+list(APPEND llfilesystem_SOURCE_FILES ${llfilesystem_HEADER_FILES})
 
-add_library (llvfs ${llvfs_SOURCE_FILES})
+add_library (llfilesystem ${llfilesystem_SOURCE_FILES})
 
-set(vfs_BOOST_LIBRARIES
+set(cache_BOOST_LIBRARIES
     ${BOOST_FILESYSTEM_LIBRARY}
     ${BOOST_SYSTEM_LIBRARY}
     )
 
-target_link_libraries(llvfs
+target_link_libraries(llfilesystem
     ${LLCOMMON_LIBRARIES}
-    ${vfs_BOOST_LIBRARIES}
+    ${cache_BOOST_LIBRARIES}
     )
 
 if (DARWIN)
   include(CMakeFindFrameworks)
   find_library(COCOA_LIBRARY Cocoa)
-  target_link_libraries(llvfs ${COCOA_LIBRARY})
+  target_link_libraries(llfilesystem ${COCOA_LIBRARY})
 endif (DARWIN)
 
 
@@ -86,18 +81,18 @@ endif (DARWIN)
 if (LL_TESTS)
     include(LLAddBuildTest)
     # UNIT TESTS
-    SET(llvfs_TEST_SOURCE_FILES
+    SET(llfilesystem_TEST_SOURCE_FILES
     lldiriterator.cpp
     )
 
     set_source_files_properties(lldiriterator.cpp
     PROPERTIES
-    LL_TEST_ADDITIONAL_LIBRARIES "${vfs_BOOST_LIBRARIES}"
+    LL_TEST_ADDITIONAL_LIBRARIES "${cache_BOOST_LIBRARIES}"
     )
-    LL_ADD_PROJECT_UNIT_TESTS(llvfs "${llvfs_TEST_SOURCE_FILES}")
+    LL_ADD_PROJECT_UNIT_TESTS(llfilesystem "${llfilesystem_TEST_SOURCE_FILES}")
 
     # INTEGRATION TESTS
-    set(test_libs llmath llcommon llvfs ${LLCOMMON_LIBRARIES} ${WINDOWS_LIBRARIES})
+    set(test_libs llmath llcommon llfilesystem ${LLCOMMON_LIBRARIES} ${WINDOWS_LIBRARIES})
 
     # TODO: Some of these need refactoring to be proper Unit tests rather than Integration tests.
     LL_ADD_INTEGRATION_TEST(lldir "" "${test_libs}")
diff --git a/indra/llvfs/lldir.cpp b/indra/llfilesystem/lldir.cpp
index 69b23f9cf8..69b23f9cf8 100644
--- a/indra/llvfs/lldir.cpp
+++ b/indra/llfilesystem/lldir.cpp
diff --git a/indra/llvfs/lldir.h b/indra/llfilesystem/lldir.h
index b9a046ba33..b9a046ba33 100644
--- a/indra/llvfs/lldir.h
+++ b/indra/llfilesystem/lldir.h
diff --git a/indra/llvfs/lldir_linux.cpp b/indra/llfilesystem/lldir_linux.cpp
index 80ad05345a..80ad05345a 100644
--- a/indra/llvfs/lldir_linux.cpp
+++ b/indra/llfilesystem/lldir_linux.cpp
diff --git a/indra/llvfs/lldir_linux.h b/indra/llfilesystem/lldir_linux.h
index e83a020ba4..e83a020ba4 100644
--- a/indra/llvfs/lldir_linux.h
+++ b/indra/llfilesystem/lldir_linux.h
diff --git a/indra/llvfs/lldir_mac.cpp b/indra/llfilesystem/lldir_mac.cpp
index 87dc1b9795..3bc4ee844e 100644
--- a/indra/llvfs/lldir_mac.cpp
+++ b/indra/llfilesystem/lldir_mac.cpp
@@ -36,7 +36,7 @@
 #include <unistd.h>
 #include <glob.h>
 #include <boost/filesystem.hpp>
-#include "llvfs_objc.h"
+#include "lldir_utils_objc.h"
 
 // --------------------------------------------------------------------------------
 
diff --git a/indra/llvfs/lldir_mac.h b/indra/llfilesystem/lldir_mac.h
index 558727ebbc..558727ebbc 100644
--- a/indra/llvfs/lldir_mac.h
+++ b/indra/llfilesystem/lldir_mac.h
diff --git a/indra/llvfs/llvfs_objc.h b/indra/llfilesystem/lldir_utils_objc.h
index 56cdbebfc5..12019c4284 100644
--- a/indra/llvfs/llvfs_objc.h
+++ b/indra/llfilesystem/lldir_utils_objc.h
@@ -1,10 +1,10 @@
 /** 
- * @file llvfs_objc.h
+ * @file lldir_utils_objc.h
  * @brief Definition of directory utilities class for Mac OS X
  *
- * $LicenseInfo:firstyear=2000&license=viewerlgpl$
+ * $LicenseInfo:firstyear=2020&license=viewerlgpl$
  * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
+ * Copyright (C) 2020, Linden Research, Inc.
  * 
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -28,8 +28,8 @@
 #error This header must not be included when compiling for any target other than Mac OS. Consider including lldir.h instead.
 #endif // !LL_DARWIN
 
-#ifndef LL_LLVFS_OBJC_H
-#define LL_LLVFS_OBJC_H
+#ifndef LL_LLDIR_UTILS_OBJC_H
+#define LL_LLDIR_UTILS_OBJC_H
 
 #include <iostream>
 
@@ -40,4 +40,4 @@ std::string* getSystemResourceFolder();
 std::string* getSystemExecutableFolder();
 
 
-#endif // LL_LLVFS_OBJC_H
+#endif // LL_LLDIR_UTILS_OBJC_H
diff --git a/indra/llvfs/llvfs_objc.mm b/indra/llfilesystem/lldir_utils_objc.mm
index 282ea41339..da55a2f897 100644
--- a/indra/llvfs/llvfs_objc.mm
+++ b/indra/llfilesystem/lldir_utils_objc.mm
@@ -1,10 +1,10 @@
 /** 
- * @file llvfs_objc.cpp
+ * @file lldir_utils_objc.mm
  * @brief Cocoa implementation of directory utilities for Mac OS X
  *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * $LicenseInfo:firstyear=2020&license=viewerlgpl$
  * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
+ * Copyright (C) 2020, Linden Research, Inc.
  * 
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -27,7 +27,7 @@
 
 //WARNING:  This file CANNOT use standard linden includes due to conflicts between definitions of BOOL
 
-#include "llvfs_objc.h"
+#include "lldir_utils_objc.h"
 #import <Cocoa/Cocoa.h>
 
 std::string* getSystemTempFolder()
diff --git a/indra/llvfs/lldir_win32.cpp b/indra/llfilesystem/lldir_win32.cpp
index b3b3afb37e..b3b3afb37e 100644
--- a/indra/llvfs/lldir_win32.cpp
+++ b/indra/llfilesystem/lldir_win32.cpp
diff --git a/indra/llvfs/lldir_win32.h b/indra/llfilesystem/lldir_win32.h
index 450efaf9da..450efaf9da 100644
--- a/indra/llvfs/lldir_win32.h
+++ b/indra/llfilesystem/lldir_win32.h
diff --git a/indra/llvfs/lldirguard.h b/indra/llfilesystem/lldirguard.h
index 37b9e9b83e..37b9e9b83e 100644
--- a/indra/llvfs/lldirguard.h
+++ b/indra/llfilesystem/lldirguard.h
diff --git a/indra/llvfs/lldiriterator.cpp b/indra/llfilesystem/lldiriterator.cpp
index f57bf4ebc6..f57bf4ebc6 100644
--- a/indra/llvfs/lldiriterator.cpp
+++ b/indra/llfilesystem/lldiriterator.cpp
diff --git a/indra/llvfs/lldiriterator.h b/indra/llfilesystem/lldiriterator.h
index 0b48be41b3..0b48be41b3 100644
--- a/indra/llvfs/lldiriterator.h
+++ b/indra/llfilesystem/lldiriterator.h
diff --git a/indra/llfilesystem/lldiskcache.cpp b/indra/llfilesystem/lldiskcache.cpp
new file mode 100644
index 0000000000..ee43a599f7
--- /dev/null
+++ b/indra/llfilesystem/lldiskcache.cpp
@@ -0,0 +1,410 @@
+/**
+ * @file lldiskcache.cpp
+ * @brief The disk cache implementation.
+ *
+ * Note: Rather than keep the top level function comments up
+ * to date in both the source and header files, I elected to
+ * only have explicit comments about each function and variable
+ * in the header - look there for details. The same is true for
+ * description of how this code is supposed to work.
+ *
+ * $LicenseInfo:firstyear=2009&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2020, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+#include "llapp.h"
+#include "llassettype.h"
+#include "lldir.h"
+#include <boost/filesystem.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <chrono>
+
+#include "lldiskcache.h"
+
+LLDiskCache::LLDiskCache(const std::string cache_dir,
+                         const uintmax_t max_size_bytes,
+                         const bool enable_cache_debug_info) :
+    mCacheDir(cache_dir),
+    mMaxSizeBytes(max_size_bytes),
+    mEnableCacheDebugInfo(enable_cache_debug_info)
+{
+    mCacheFilenamePrefix = "sl_cache";
+
+    LLFile::mkdir(cache_dir);
+}
+
+// WARNING: purge() is called by LLPurgeDiskCacheThread. As such it must
+// NOT touch any LLDiskCache data without introducing and locking a mutex!
+
+// Interaction through the filesystem itself should be safe. Let’s say thread
+// A is accessing the cache file for reading/writing and thread B is trimming
+// the cache. Let’s also assume using llifstream to open a file and
+// boost::filesystem::remove are not atomic (which will be pretty much the
+// case).
+
+// Now, A is trying to open the file using llifstream ctor. It does some
+// checks if the file exists and whatever else it might be doing, but has not
+// issued the call to the OS to actually open the file yet. Now B tries to
+// delete the file: If the file has been already marked as in use by the OS,
+// deleting the file will fail and B will continue with the next file. A can
+// safely continue opening the file. If the file has not yet been marked as in
+// use, B will delete the file. Now A actually wants to open it, operation
+// will fail, subsequent check via llifstream.is_open will fail, asset will
+// have to be re-requested. (Assuming here the viewer will actually handle
+// this situation properly, that can also happen if there is a file containing
+// garbage.)
+
+// Other situation: B is trimming the cache and A wants to read a file that is
+// about to get deleted. boost::filesystem::remove does whatever it is doing
+// before actually deleting the file. If A opens the file before the file is
+// actually gone, the OS call from B to delete the file will fail since the OS
+// will prevent this. B continues with the next file. If the file is already
+// gone before A finally gets to open it, this operation will fail and the
+// asset will have to be re-requested.
+void LLDiskCache::purge()
+{
+    if (mEnableCacheDebugInfo)
+    {
+        LL_INFOS() << "Total dir size before purge is " << dirFileSize(mCacheDir) << LL_ENDL;
+    }
+
+    boost::system::error_code ec;
+    auto start_time = std::chrono::high_resolution_clock::now();
+
+    typedef std::pair<std::time_t, std::pair<uintmax_t, std::string>> file_info_t;
+    std::vector<file_info_t> file_info;
+
+#if LL_WINDOWS
+    std::wstring cache_path(utf8str_to_utf16str(mCacheDir));
+#else
+    std::string cache_path(mCacheDir);
+#endif
+    if (boost::filesystem::is_directory(cache_path, ec) && !ec.failed())
+    {
+        for (auto& entry : boost::make_iterator_range(boost::filesystem::directory_iterator(cache_path, ec), {}))
+        {
+            if (boost::filesystem::is_regular_file(entry, ec) && !ec.failed())
+            {
+                if (entry.path().string().find(mCacheFilenamePrefix) != std::string::npos)
+                {
+                    uintmax_t file_size = boost::filesystem::file_size(entry, ec);
+                    if (ec.failed())
+                    {
+                        continue;
+                    }
+                    const std::string file_path = entry.path().string();
+                    const std::time_t file_time = boost::filesystem::last_write_time(entry, ec);
+                    if (ec.failed())
+                    {
+                        continue;
+                    }
+
+                    file_info.push_back(file_info_t(file_time, { file_size, file_path }));
+                }
+            }
+        }
+    }
+
+    std::sort(file_info.begin(), file_info.end(), [](file_info_t& x, file_info_t& y)
+    {
+        return x.first > y.first;
+    });
+
+    LL_INFOS() << "Purging cache to a maximum of " << mMaxSizeBytes << " bytes" << LL_ENDL;
+
+    uintmax_t file_size_total = 0;
+    for (file_info_t& entry : file_info)
+    {
+        file_size_total += entry.second.first;
+
+        std::string action = "";
+        if (file_size_total > mMaxSizeBytes)
+        {
+            action = "DELETE:";
+            boost::filesystem::remove(entry.second.second, ec);
+            if (ec.failed())
+            {
+                LL_WARNS() << "Failed to delete cache file " << entry.second.second << ": " << ec.message() << LL_ENDL;
+            }
+        }
+        else
+        {
+            action = "  KEEP:";
+        }
+
+        if (mEnableCacheDebugInfo)
+        {
+            // have to do this because of LL_INFO/LL_END weirdness
+            std::ostringstream line;
+
+            line << action << "  ";
+            line << entry.first << "  ";
+            line << entry.second.first << "  ";
+            line << entry.second.second;
+            line << " (" << file_size_total << "/" << mMaxSizeBytes << ")";
+            LL_INFOS() << line.str() << LL_ENDL;
+        }
+    }
+
+    if (mEnableCacheDebugInfo)
+    {
+        auto end_time = std::chrono::high_resolution_clock::now();
+        auto execute_time = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count();
+        LL_INFOS() << "Total dir size after purge is " << dirFileSize(mCacheDir) << LL_ENDL;
+        LL_INFOS() << "Cache purge took " << execute_time << " ms to execute for " << file_info.size() << " files" << LL_ENDL;
+    }
+}
+
+const std::string LLDiskCache::assetTypeToString(LLAssetType::EType at)
+{
+    /**
+     * Make use of the handy C++17  feature that allows
+     * for inline initialization of an std::map<>
+     */
+    typedef std::map<LLAssetType::EType, std::string> asset_type_to_name_t;
+    asset_type_to_name_t asset_type_to_name =
+    {
+        { LLAssetType::AT_TEXTURE, "TEXTURE" },
+        { LLAssetType::AT_SOUND, "SOUND" },
+        { LLAssetType::AT_CALLINGCARD, "CALLINGCARD" },
+        { LLAssetType::AT_LANDMARK, "LANDMARK" },
+        { LLAssetType::AT_SCRIPT, "SCRIPT" },
+        { LLAssetType::AT_CLOTHING, "CLOTHING" },
+        { LLAssetType::AT_OBJECT, "OBJECT" },
+        { LLAssetType::AT_NOTECARD, "NOTECARD" },
+        { LLAssetType::AT_CATEGORY, "CATEGORY" },
+        { LLAssetType::AT_LSL_TEXT, "LSL_TEXT" },
+        { LLAssetType::AT_LSL_BYTECODE, "LSL_BYTECODE" },
+        { LLAssetType::AT_TEXTURE_TGA, "TEXTURE_TGA" },
+        { LLAssetType::AT_BODYPART, "BODYPART" },
+        { LLAssetType::AT_SOUND_WAV, "SOUND_WAV" },
+        { LLAssetType::AT_IMAGE_TGA, "IMAGE_TGA" },
+        { LLAssetType::AT_IMAGE_JPEG, "IMAGE_JPEG" },
+        { LLAssetType::AT_ANIMATION, "ANIMATION" },
+        { LLAssetType::AT_GESTURE, "GESTURE" },
+        { LLAssetType::AT_SIMSTATE, "SIMSTATE" },
+        { LLAssetType::AT_LINK, "LINK" },
+        { LLAssetType::AT_LINK_FOLDER, "LINK_FOLDER" },
+        { LLAssetType::AT_MARKETPLACE_FOLDER, "MARKETPLACE_FOLDER" },
+        { LLAssetType::AT_WIDGET, "WIDGET" },
+        { LLAssetType::AT_PERSON, "PERSON" },
+        { LLAssetType::AT_MESH, "MESH" },
+        { LLAssetType::AT_SETTINGS, "SETTINGS" },
+        { LLAssetType::AT_UNKNOWN, "UNKNOWN" }
+    };
+
+    asset_type_to_name_t::iterator iter = asset_type_to_name.find(at);
+    if (iter != asset_type_to_name.end())
+    {
+        return iter->second;
+    }
+
+    return std::string("UNKNOWN");
+}
+
+const std::string LLDiskCache::metaDataToFilepath(const std::string id,
+        LLAssetType::EType at,
+        const std::string extra_info)
+{
+    std::ostringstream file_path;
+
+    file_path << mCacheDir;
+    file_path << gDirUtilp->getDirDelimiter();
+    file_path << mCacheFilenamePrefix;
+    file_path << "_";
+    file_path << id;
+    file_path << "_";
+    file_path << (extra_info.empty() ? "0" : extra_info);
+    //file_path << "_";
+    //file_path << assetTypeToString(at); // see  SL-14210 Prune descriptive tag from new cache filenames
+                                          // for details of why it was removed. Note that if you put it
+                                          // back or change the format of the filename, the cache files
+                                          // files will be invalidated (and perhaps, more importantly,
+                                          // never deleted unless you delete them manually).
+    file_path << ".asset";
+
+    return file_path.str();
+}
+
+void LLDiskCache::updateFileAccessTime(const std::string file_path)
+{
+    /**
+     * Threshold in time_t units that is used to decide if the last access time
+     * time of the file is updated or not. Added as a precaution for the concern
+     * outlined in SL-14582  about frequent writes on older SSDs reducing their
+     * lifespan. I think this is the right place for the threshold value - rather
+     * than it being a pref - do comment on that Jira if you disagree...
+     *
+     * Let's start with 1 hour in time_t units and see how that unfolds
+     */
+    const std::time_t time_threshold = 1 * 60 * 60;
+
+    // current time
+    const std::time_t cur_time = std::time(nullptr);
+
+    boost::system::error_code ec;
+#if LL_WINDOWS
+    // file last write time
+    const std::time_t last_write_time = boost::filesystem::last_write_time(utf8str_to_utf16str(file_path), ec);
+    if (ec.failed())
+    {
+        LL_WARNS() << "Failed to read last write time for cache file " << file_path << ": " << ec.message() << LL_ENDL;
+        return;
+    }
+
+    // delta between cur time and last time the file was written
+    const std::time_t delta_time = cur_time - last_write_time;
+
+    // we only write the new value if the time in time_threshold has elapsed
+    // before the last one
+    if (delta_time > time_threshold)
+    {
+        boost::filesystem::last_write_time(utf8str_to_utf16str(file_path), cur_time, ec);
+    }
+#else
+    // file last write time
+    const std::time_t last_write_time = boost::filesystem::last_write_time(file_path, ec);
+    if (ec.failed())
+    {
+        LL_WARNS() << "Failed to read last write time for cache file " << file_path << ": " << ec.message() << LL_ENDL;
+        return;
+    }
+
+    // delta between cur time and last time the file was written
+    const std::time_t delta_time = cur_time - last_write_time;
+
+    // we only write the new value if the time in time_threshold has elapsed
+    // before the last one
+    if (delta_time > time_threshold)
+    {
+        boost::filesystem::last_write_time(file_path, cur_time, ec);
+    }
+#endif
+
+    if (ec.failed())
+    {
+        LL_WARNS() << "Failed to update last write time for cache file " << file_path << ": " << ec.message() << LL_ENDL;
+    }
+}
+
+const std::string LLDiskCache::getCacheInfo()
+{
+    std::ostringstream cache_info;
+
+    F32 max_in_mb = (F32)mMaxSizeBytes / (1024.0 * 1024.0);
+    F32 percent_used = ((F32)dirFileSize(mCacheDir) / (F32)mMaxSizeBytes) * 100.0;
+
+    cache_info << std::fixed;
+    cache_info << std::setprecision(1);
+    cache_info << "Max size " << max_in_mb << " MB ";
+    cache_info << "(" << percent_used << "% used)";
+
+    return cache_info.str();
+}
+
+void LLDiskCache::clearCache()
+{
+    /**
+     * See notes on performance in dirFileSize(..) - there may be
+     * a quicker way to do this by operating on the parent dir vs
+     * the component files but it's called infrequently so it's
+     * likely just fine
+     */
+    boost::system::error_code ec;
+#if LL_WINDOWS
+    std::wstring cache_path(utf8str_to_utf16str(mCacheDir));
+#else
+    std::string cache_path(mCacheDir);
+#endif
+    if (boost::filesystem::is_directory(cache_path, ec) && !ec.failed())
+    {
+        for (auto& entry : boost::make_iterator_range(boost::filesystem::directory_iterator(cache_path, ec), {}))
+        {
+            if (boost::filesystem::is_regular_file(entry, ec) && !ec.failed())
+            {
+                if (entry.path().string().find(mCacheFilenamePrefix) != std::string::npos)
+                {
+                    boost::filesystem::remove(entry, ec);
+                    if (ec.failed())
+                    {
+                        LL_WARNS() << "Failed to delete cache file " << entry << ": " << ec.message() << LL_ENDL;
+                    }
+                }
+            }
+        }
+    }
+}
+
+uintmax_t LLDiskCache::dirFileSize(const std::string dir)
+{
+    uintmax_t total_file_size = 0;
+
+    /**
+     * There may be a better way that works directly on the folder (similar to
+     * right clicking on a folder in the OS and asking for size vs right clicking
+     * on all files and adding up manually) but this is very fast - less than 100ms
+     * for 10,000 files in my testing so, so long as it's not called frequently,
+     * it should be okay. Note that's it's only currently used for logging/debugging
+     * so if performance is ever an issue, optimizing this or removing it altogether,
+     * is an easy win.
+     */
+    boost::system::error_code ec;
+#if LL_WINDOWS
+    std::wstring dir_path(utf8str_to_utf16str(dir));
+#else
+    std::string dir_path(dir);
+#endif
+    if (boost::filesystem::is_directory(dir_path, ec) && !ec.failed())
+    {
+        for (auto& entry : boost::make_iterator_range(boost::filesystem::directory_iterator(dir_path, ec), {}))
+        {
+            if (boost::filesystem::is_regular_file(entry, ec) && !ec.failed())
+            {
+                if (entry.path().string().find(mCacheFilenamePrefix) != std::string::npos)
+                {
+                    uintmax_t file_size = boost::filesystem::file_size(entry, ec);
+                    if (!ec.failed())
+                    {
+                        total_file_size += file_size;
+                    }
+                }
+            }
+        }
+    }
+
+    return total_file_size;
+}
+
+LLPurgeDiskCacheThread::LLPurgeDiskCacheThread() :
+    LLThread("PurgeDiskCacheThread", nullptr)
+{
+}
+
+void LLPurgeDiskCacheThread::run()
+{
+    constexpr std::chrono::seconds CHECK_INTERVAL{60};
+
+    while (LLApp::instance()->sleep(CHECK_INTERVAL))
+    {
+        LLDiskCache::instance().purge();
+    }
+}
diff --git a/indra/llfilesystem/lldiskcache.h b/indra/llfilesystem/lldiskcache.h
new file mode 100644
index 0000000000..1cbd2c58aa
--- /dev/null
+++ b/indra/llfilesystem/lldiskcache.h
@@ -0,0 +1,198 @@
+/**
+ * @file lldiskcache.h
+ * @brief The disk cache implementation declarations.
+ *
+ * @Description:
+ * This code implements a disk cache using the following ideas:
+ * 1/ The metadata for a file can be encapsulated in the filename.
+      The filenames will be composed of the following fields:
+        Prefix:     Used to identify the file as a part of the cache.
+                    An additional reason for using a prefix is that it
+                    might be possible, either accidentally or maliciously
+                    to end up with the cache dir set to a non-cache
+                    location such as your OS system dir or a work folder.
+                    Purging files from that would obviously be a disaster
+                    so this is an extra step to help avoid that scenario.
+        ID:         Typically the asset ID (UUID) of the asset being
+                    saved but can be anything valid for a filename
+        Extra Info: A field for use in the future that can be used
+                    to store extra identifiers - e.g. the discard
+                    level of a JPEG2000 file
+        Asset Type: A text string created from the LLAssetType enum
+                    that identifies the type of asset being stored.
+        .asset      A file extension of .asset is used to help
+                    identify this as a Viewer asset file
+ * 2/ The time of last access for a file can be updated instantly
+ *    for file reads and automatically as part of the file writes.
+ * 3/ The purge algorithm collects a list of all files in the
+ *    directory, sorts them by date of last access (write) and then
+ *    deletes any files based on age until the total size of all
+ *    the files is less than the maximum size specified.
+ * 4/ An LLSingleton idiom is used since there will only ever be
+ *    a single cache and we want to access it from numerous places.
+ * 5/ Performance on my modest system seems very acceptable. For
+ *    example, in testing, I was able to purge a directory of
+ *    10,000 files, deleting about half of them in ~ 1700ms. For
+ *    the same sized directory of files, writing the last updated
+ *    time to each took less than 600ms indicating that this
+ *    important part of the mechanism has almost no overhead.
+ *
+ * $LicenseInfo:firstyear=2009&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2020, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef _LLDISKCACHE
+#define _LLDISKCACHE
+
+#include "llsingleton.h"
+
+class LLDiskCache :
+    public LLParamSingleton<LLDiskCache>
+{
+    public:
+        /**
+         * Since this is using the LLSingleton pattern but we
+         * want to allow the constructor to be called first
+         * with various parameters, we also invoke the
+         * LLParamSingleton idiom and use it to initialize
+         * the class via a call in LLAppViewer.
+         */
+        LLSINGLETON(LLDiskCache,
+                    /**
+                     * The full name of the cache folder - typically a
+                     * a child of the main Viewer cache directory. Defined
+                     * by the setting at 'DiskCacheDirName'
+                     */
+                    const std::string cache_dir,
+                    /**
+                     * The maximum size of the cache in bytes - Based on the
+                     * setting at 'CacheSize' and 'DiskCachePercentOfTotal'
+                     */
+                    const uintmax_t max_size_bytes,
+                    /**
+                     * A flag that enables extra cache debugging so that
+                     * if there are bugs, we can ask uses to enable this
+                     * setting and send us their logs
+                     */
+                    const bool enable_cache_debug_info);
+
+        virtual ~LLDiskCache() = default;
+
+    public:
+        /**
+         * Construct a filename and path to it based on the file meta data
+         * (id, asset type, additional 'extra' info like discard level perhaps)
+         * Worth pointing out that this function used to be in LLFileSystem but
+         * so many things had to be pushed back there to accomodate it, that I
+         * decided to move it here.  Still not sure that's completely right.
+         */
+        const std::string metaDataToFilepath(const std::string id,
+                                             LLAssetType::EType at,
+                                             const std::string extra_info);
+
+        /**
+         * Update the "last write time" of a file to "now". This must be called whenever a
+         * file in the cache is read (not written) so that the last time the file was
+         * accessed is up to date (This is used in the mechanism for purging the cache)
+         */
+        void updateFileAccessTime(const std::string file_path);
+
+        /**
+         * Purge the oldest items in the cache so that the combined size of all files
+         * is no bigger than mMaxSizeBytes.
+         *
+         * WARNING: purge() is called by LLPurgeDiskCacheThread. As such it must
+         * NOT touch any LLDiskCache data without introducing and locking a mutex!
+         *
+         * Purging the disk cache involves nontrivial work on the viewer's
+         * filesystem. If called on the main thread, this causes a noticeable
+         * freeze.
+         */
+        void purge();
+
+        /**
+         * Clear the cache by removing all the files in the specified cache
+         * directory individually. Only the files that contain a prefix defined
+         * by mCacheFilenamePrefix will be removed.
+         */
+        void clearCache();
+
+        /**
+         * Return some information about the cache for use in About Box etc.
+         */
+        const std::string getCacheInfo();
+
+    private:
+        /**
+         * Utility function to gather the total size the files in a given
+         * directory. Primarily used here to determine the directory size
+         * before and after the cache purge
+         */
+        uintmax_t dirFileSize(const std::string dir);
+
+        /**
+         * Utility function to convert an LLAssetType enum into a
+         * string that we use as part of the cache file filename
+         */
+        const std::string assetTypeToString(LLAssetType::EType at);
+
+    private:
+        /**
+         * The maximum size of the cache in bytes. After purge is called, the
+         * total size of the cache files in the cache directory will be
+         * less than this value
+         */
+        uintmax_t mMaxSizeBytes;
+
+        /**
+         * The folder that holds the cached files. The consumer of this
+         * class must avoid letting the user set this location as a malicious
+         * setting could potentially point it at a non-cache directory (for example,
+         * the Windows System dir) with disastrous results.
+         */
+        std::string mCacheDir;
+
+        /**
+         * The prefix inserted at the start of a cache file filename to
+         * help identify it as a cache file. It's probably not required
+         * (just the presence in the cache folder is enough) but I am
+         * paranoid about the cache folder being set to something bad
+         * like the users' OS system dir by mistake or maliciously and
+         * this will help to offset any damage if that happens.
+         */
+        std::string mCacheFilenamePrefix;
+
+        /**
+         * When enabled, displays additional debugging information in
+         * various parts of the code
+         */
+        bool mEnableCacheDebugInfo;
+};
+
+class LLPurgeDiskCacheThread : public LLThread
+{
+public:
+    LLPurgeDiskCacheThread();
+
+protected:
+    void run() override;
+};
+#endif // _LLDISKCACHE
diff --git a/indra/llfilesystem/llfilesystem.cpp b/indra/llfilesystem/llfilesystem.cpp
new file mode 100644
index 0000000000..4c836c8838
--- /dev/null
+++ b/indra/llfilesystem/llfilesystem.cpp
@@ -0,0 +1,326 @@
+/**
+ * @file filesystem.h
+ * @brief Simulate local file system operations.
+ * @Note The initial implementation does actually use standard C++
+ *       file operations but eventually, there will be another
+ *       layer that caches and manages file meta data too.
+ *
+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "lldir.h"
+#include "llfilesystem.h"
+#include "llfasttimer.h"
+#include "lldiskcache.h"
+
+const S32 LLFileSystem::READ        = 0x00000001;
+const S32 LLFileSystem::WRITE       = 0x00000002;
+const S32 LLFileSystem::READ_WRITE  = 0x00000003;  // LLFileSystem::READ & LLFileSystem::WRITE
+const S32 LLFileSystem::APPEND      = 0x00000006;  // 0x00000004 & LLFileSystem::WRITE
+
+static LLTrace::BlockTimerStatHandle FTM_VFILE_WAIT("VFile Wait");
+
+LLFileSystem::LLFileSystem(const LLUUID& file_id, const LLAssetType::EType file_type, S32 mode)
+{
+    mFileType = file_type;
+    mFileID = file_id;
+    mPosition = 0;
+    mBytesRead = 0;
+    mMode = mode;
+
+    // This block of code was originally called in the read() method but after comments here:
+    // https://bitbucket.org/lindenlab/viewer/commits/e28c1b46e9944f0215a13cab8ee7dded88d7fc90#comment-10537114
+    // we decided to follow Henri's suggestion and move the code to update the last access time here.
+    if (mode == LLFileSystem::READ)
+    {
+        // build the filename (TODO: we do this in a few places - perhaps we should factor into a single function)
+        std::string id;
+        mFileID.toString(id);
+        const std::string extra_info = "";
+        const std::string filename = LLDiskCache::getInstance()->metaDataToFilepath(id, mFileType, extra_info);
+
+        // update the last access time for the file if it exists - this is required
+        // even though we are reading and not writing because this is the
+        // way the cache works - it relies on a valid "last accessed time" for
+        // each file so it knows how to remove the oldest, unused files
+        bool exists = gDirUtilp->fileExists(filename);
+        if (exists)
+        {
+            LLDiskCache::getInstance()->updateFileAccessTime(filename);
+        }
+    }
+}
+
+LLFileSystem::~LLFileSystem()
+{
+}
+
+// static
+bool LLFileSystem::getExists(const LLUUID& file_id, const LLAssetType::EType file_type)
+{
+    std::string id_str;
+    file_id.toString(id_str);
+    const std::string extra_info = "";
+    const std::string filename = LLDiskCache::getInstance()->metaDataToFilepath(id_str, file_type, extra_info);
+
+    llifstream file(filename, std::ios::binary);
+    if (file.is_open())
+    {
+        file.seekg(0, std::ios::end);
+        return file.tellg() > 0;
+    }
+    return false;
+}
+
+// static
+bool LLFileSystem::removeFile(const LLUUID& file_id, const LLAssetType::EType file_type, int suppress_error /*= 0*/)
+{
+    std::string id_str;
+    file_id.toString(id_str);
+    const std::string extra_info = "";
+    const std::string filename =  LLDiskCache::getInstance()->metaDataToFilepath(id_str, file_type, extra_info);
+
+    LLFile::remove(filename.c_str(), suppress_error);
+
+    return true;
+}
+
+// static
+bool LLFileSystem::renameFile(const LLUUID& old_file_id, const LLAssetType::EType old_file_type,
+                              const LLUUID& new_file_id, const LLAssetType::EType new_file_type)
+{
+    std::string old_id_str;
+    old_file_id.toString(old_id_str);
+    const std::string extra_info = "";
+    const std::string old_filename =  LLDiskCache::getInstance()->metaDataToFilepath(old_id_str, old_file_type, extra_info);
+
+    std::string new_id_str;
+    new_file_id.toString(new_id_str);
+    const std::string new_filename =  LLDiskCache::getInstance()->metaDataToFilepath(new_id_str, new_file_type, extra_info);
+
+    // Rename needs the new file to not exist.
+    LLFileSystem::removeFile(new_file_id, new_file_type, ENOENT);
+
+    if (LLFile::rename(old_filename, new_filename) != 0)
+    {
+        // We would like to return FALSE here indicating the operation
+        // failed but the original code does not and doing so seems to
+        // break a lot of things so we go with the flow...
+        //return FALSE;
+        LL_WARNS() << "Failed to rename " << old_file_id << " to " << new_id_str << " reason: "  << strerror(errno) << LL_ENDL;
+    }
+
+    return TRUE;
+}
+
+// static
+S32 LLFileSystem::getFileSize(const LLUUID& file_id, const LLAssetType::EType file_type)
+{
+    std::string id_str;
+    file_id.toString(id_str);
+    const std::string extra_info = "";
+    const std::string filename =  LLDiskCache::getInstance()->metaDataToFilepath(id_str, file_type, extra_info);
+
+    S32 file_size = 0;
+    llifstream file(filename, std::ios::binary);
+    if (file.is_open())
+    {
+        file.seekg(0, std::ios::end);
+        file_size = file.tellg();
+    }
+
+    return file_size;
+}
+
+BOOL LLFileSystem::read(U8* buffer, S32 bytes)
+{
+    BOOL success = FALSE;
+
+    std::string id;
+    mFileID.toString(id);
+    const std::string extra_info = "";
+    const std::string filename =  LLDiskCache::getInstance()->metaDataToFilepath(id, mFileType, extra_info);
+
+    llifstream file(filename, std::ios::binary);
+    if (file.is_open())
+    {
+        file.seekg(mPosition, std::ios::beg);
+
+        file.read((char*)buffer, bytes);
+
+        if (file)
+        {
+            mBytesRead = bytes;
+        }
+        else
+        {
+            mBytesRead = file.gcount();
+        }
+
+        file.close();
+
+        mPosition += mBytesRead;
+        if (mBytesRead)
+        {
+            success = TRUE;
+        }
+    }
+
+    return success;
+}
+
+S32 LLFileSystem::getLastBytesRead()
+{
+    return mBytesRead;
+}
+
+BOOL LLFileSystem::eof()
+{
+    return mPosition >= getSize();
+}
+
+BOOL LLFileSystem::write(const U8* buffer, S32 bytes)
+{
+    std::string id_str;
+    mFileID.toString(id_str);
+    const std::string extra_info = "";
+    const std::string filename =  LLDiskCache::getInstance()->metaDataToFilepath(id_str, mFileType, extra_info);
+
+    BOOL success = FALSE;
+
+    if (mMode == APPEND)
+    {
+        llofstream ofs(filename, std::ios::app | std::ios::binary);
+        if (ofs)
+        {
+            ofs.write((const char*)buffer, bytes);
+
+            mPosition = ofs.tellp(); // <FS:Ansariel> Fix asset caching
+
+            success = TRUE;
+        }
+    }
+    // <FS:Ansariel> Fix asset caching
+    else if (mMode == READ_WRITE)
+    {
+        // Don't truncate if file already exists
+        llofstream ofs(filename, std::ios::in | std::ios::binary);
+        if (ofs)
+        {
+            ofs.seekp(mPosition, std::ios::beg);
+            ofs.write((const char*)buffer, bytes);
+            mPosition += bytes;
+            success = TRUE;
+        }
+        else
+        {
+            // File doesn't exist - open in write mode
+            ofs.open(filename, std::ios::binary);
+            if (ofs.is_open())
+            {
+                ofs.write((const char*)buffer, bytes);
+                mPosition += bytes;
+                success = TRUE;
+            }
+        }
+    }
+    // </FS:Ansariel>
+    else
+    {
+        llofstream ofs(filename, std::ios::binary);
+        if (ofs)
+        {
+            ofs.write((const char*)buffer, bytes);
+
+            mPosition += bytes;
+
+            success = TRUE;
+        }
+    }
+
+    return success;
+}
+
+BOOL LLFileSystem::seek(S32 offset, S32 origin)
+{
+    if (-1 == origin)
+    {
+        origin = mPosition;
+    }
+
+    S32 new_pos = origin + offset;
+
+    S32 size = getSize();
+
+    if (new_pos > size)
+    {
+        LL_WARNS() << "Attempt to seek past end of file" << LL_ENDL;
+
+        mPosition = size;
+        return FALSE;
+    }
+    else if (new_pos < 0)
+    {
+        LL_WARNS() << "Attempt to seek past beginning of file" << LL_ENDL;
+
+        mPosition = 0;
+        return FALSE;
+    }
+
+    mPosition = new_pos;
+    return TRUE;
+}
+
+S32 LLFileSystem::tell() const
+{
+    return mPosition;
+}
+
+S32 LLFileSystem::getSize()
+{
+    return LLFileSystem::getFileSize(mFileID, mFileType);
+}
+
+S32 LLFileSystem::getMaxSize()
+{
+    // offer up a huge size since we don't care what the max is
+    return INT_MAX;
+}
+
+BOOL LLFileSystem::rename(const LLUUID& new_id, const LLAssetType::EType new_type)
+{
+    LLFileSystem::renameFile(mFileID, mFileType, new_id, new_type);
+
+    mFileID = new_id;
+    mFileType = new_type;
+
+    return TRUE;
+}
+
+BOOL LLFileSystem::remove()
+{
+    LLFileSystem::removeFile(mFileID, mFileType);
+
+    return TRUE;
+}
diff --git a/indra/llfilesystem/llfilesystem.h b/indra/llfilesystem/llfilesystem.h
new file mode 100644
index 0000000000..d934a408c2
--- /dev/null
+++ b/indra/llfilesystem/llfilesystem.h
@@ -0,0 +1,78 @@
+/**
+ * @file filesystem.h
+ * @brief Simulate local file system operations.
+ * @Note The initial implementation does actually use standard C++
+ *       file operations but eventually, there will be another
+ *       layer that caches and manages file meta data too.
+ *
+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_FILESYSTEM_H
+#define LL_FILESYSTEM_H
+
+#include "lluuid.h"
+#include "llassettype.h"
+#include "lldiskcache.h"
+
+class LLFileSystem
+{
+    public:
+        LLFileSystem(const LLUUID& file_id, const LLAssetType::EType file_type, S32 mode = LLFileSystem::READ);
+        ~LLFileSystem();
+
+        BOOL read(U8* buffer, S32 bytes);
+        S32  getLastBytesRead();
+        BOOL eof();
+
+        BOOL write(const U8* buffer, S32 bytes);
+        BOOL seek(S32 offset, S32 origin = -1);
+        S32  tell() const;
+
+        S32 getSize();
+        S32 getMaxSize();
+        BOOL rename(const LLUUID& new_id, const LLAssetType::EType new_type);
+        BOOL remove();
+
+        static bool getExists(const LLUUID& file_id, const LLAssetType::EType file_type);
+        static bool removeFile(const LLUUID& file_id, const LLAssetType::EType file_type, int suppress_error = 0);
+        static bool renameFile(const LLUUID& old_file_id, const LLAssetType::EType old_file_type,
+                               const LLUUID& new_file_id, const LLAssetType::EType new_file_type);
+        static S32 getFileSize(const LLUUID& file_id, const LLAssetType::EType file_type);
+
+    public:
+        static const S32 READ;
+        static const S32 WRITE;
+        static const S32 READ_WRITE;
+        static const S32 APPEND;
+
+    protected:
+        LLAssetType::EType mFileType;
+        LLUUID  mFileID;
+        S32     mPosition;
+        S32     mMode;
+        S32     mBytesRead;
+//private:
+//    static const std::string idToFilepath(const std::string id, LLAssetType::EType at);
+};
+
+#endif  // LL_FILESYSTEM_H
diff --git a/indra/llvfs/lllfsthread.cpp b/indra/llfilesystem/lllfsthread.cpp
index be8e83a56f..be8e83a56f 100644
--- a/indra/llvfs/lllfsthread.cpp
+++ b/indra/llfilesystem/lllfsthread.cpp
diff --git a/indra/llvfs/lllfsthread.h b/indra/llfilesystem/lllfsthread.h
index 58f658f7ba..58f658f7ba 100644
--- a/indra/llvfs/lllfsthread.h
+++ b/indra/llfilesystem/lllfsthread.h
diff --git a/indra/llvfs/tests/lldir_test.cpp b/indra/llfilesystem/tests/lldir_test.cpp
index 3cff622a4b..3cff622a4b 100644
--- a/indra/llvfs/tests/lldir_test.cpp
+++ b/indra/llfilesystem/tests/lldir_test.cpp
diff --git a/indra/llvfs/tests/lldiriterator_test.cpp b/indra/llfilesystem/tests/lldiriterator_test.cpp
index a65e3dada5..a65e3dada5 100644
--- a/indra/llvfs/tests/lldiriterator_test.cpp
+++ b/indra/llfilesystem/tests/lldiriterator_test.cpp
diff --git a/indra/llimage/CMakeLists.txt b/indra/llimage/CMakeLists.txt
index 28b8e8c06d..8883317751 100644
--- a/indra/llimage/CMakeLists.txt
+++ b/indra/llimage/CMakeLists.txt
@@ -6,7 +6,7 @@ include(00-Common)
 include(LLCommon)
 include(LLImage)
 include(LLMath)
-include(LLVFS)
+include(LLFileSystem)
 include(LLKDU)
 include(LLImageJ2COJ)
 include(ZLIB)
@@ -18,7 +18,7 @@ include_directories(
     ${LLCOMMON_INCLUDE_DIRS}
     ${LLCOMMON_SYSTEM_INCLUDE_DIRS}
     ${LLMATH_INCLUDE_DIRS}
-    ${LLVFS_INCLUDE_DIRS}
+    ${LLFILESYSTEM_INCLUDE_DIRS}
     ${PNG_INCLUDE_DIRS}
     ${ZLIB_INCLUDE_DIRS}
     )
@@ -69,7 +69,7 @@ else (USE_KDU)
 endif (USE_KDU)
 
 target_link_libraries(llimage
-    ${LLVFS_LIBRARIES}
+    ${LLFILESYSTEM_LIBRARIES}
     ${LLMATH_LIBRARIES}
     ${LLCOMMON_LIBRARIES}
     ${JPEG_LIBRARIES}
diff --git a/indra/llimage/llimage.cpp b/indra/llimage/llimage.cpp
index 983c7c2406..8922f46ffe 100644
--- a/indra/llimage/llimage.cpp
+++ b/indra/llimage/llimage.cpp
@@ -2224,20 +2224,11 @@ bool LLImageFormatted::save(const std::string &filename)
 	return true;
 }
 
-// bool LLImageFormatted::save(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type)
-// Depricated to remove VFS dependency.
-// Use:
-// LLVFile::writeFile(image->getData(), image->getDataSize(), vfs, uuid, type);
-
-//----------------------------------------------------------------------------
-
 S8 LLImageFormatted::getCodec() const
 {
 	return mCodec;
 }
 
-//============================================================================
-
 static void avg4_colors4(const U8* a, const U8* b, const U8* c, const U8* d, U8* dst)
 {
 	dst[0] = (U8)(((U32)(a[0]) + b[0] + c[0] + d[0])>>2);
diff --git a/indra/llinventory/CMakeLists.txt b/indra/llinventory/CMakeLists.txt
index e829788c91..04975940aa 100644
--- a/indra/llinventory/CMakeLists.txt
+++ b/indra/llinventory/CMakeLists.txt
@@ -7,7 +7,7 @@ include(LLCommon)
 include(LLCoreHttp)
 include(LLMath)
 include(LLMessage)
-include(LLVFS)
+include(LLFileSystem)
 include(LLXML)
 
 include_directories(
@@ -81,7 +81,7 @@ if (LL_TESTS)
     LL_ADD_PROJECT_UNIT_TESTS(llinventory "${llinventory_TEST_SOURCE_FILES}")
 
     #set(TEST_DEBUG on)
-    set(test_libs llinventory ${LLMESSAGE_LIBRARIES} ${LLVFS_LIBRARIES} ${LLCOREHTTP_LIBRARIES} ${LLMATH_LIBRARIES} ${LLCOMMON_LIBRARIES} ${WINDOWS_LIBRARIES})
+    set(test_libs llinventory ${LLMESSAGE_LIBRARIES} ${LLFILESYSTEM_LIBRARIES} ${LLCOREHTTP_LIBRARIES} ${LLMATH_LIBRARIES} ${LLCOMMON_LIBRARIES} ${WINDOWS_LIBRARIES})
     LL_ADD_INTEGRATION_TEST(inventorymisc "" "${test_libs}")
     LL_ADD_INTEGRATION_TEST(llparcel "" "${test_libs}")
 endif (LL_TESTS)
diff --git a/indra/llmessage/CMakeLists.txt b/indra/llmessage/CMakeLists.txt
index 2f99ca069e..f0a1dfe940 100644
--- a/indra/llmessage/CMakeLists.txt
+++ b/indra/llmessage/CMakeLists.txt
@@ -9,7 +9,7 @@ include(LLCommon)
 include(LLCoreHttp)
 include(LLMath)
 include(LLMessage)
-include(LLVFS)
+include(LLFileSystem)
 include(LLAddBuildTest)
 include(Python)
 include(Tut)
@@ -23,7 +23,7 @@ include_directories(
     ${LLCOREHTTP_INCLUDE_DIRS}
     ${LLMATH_INCLUDE_DIRS}
     ${LLMESSAGE_INCLUDE_DIRS}
-    ${LLVFS_INCLUDE_DIRS}
+    ${LLFILESYSTEM_INCLUDE_DIRS}
     ${JSONCPP_INCLUDE_DIR}
     )
 
@@ -209,7 +209,7 @@ target_link_libraries(
   llmessage
   ${CURL_LIBRARIES}
   ${LLCOMMON_LIBRARIES}
-  ${LLVFS_LIBRARIES}
+  ${LLFILESYSTEM_LIBRARIES}
   ${LLMATH_LIBRARIES}
   ${JSONCPP_LIBRARIES}
   ${OPENSSL_LIBRARIES}
@@ -227,7 +227,7 @@ target_link_libraries(
   llmessage
   ${CURL_LIBRARIES}
   ${LLCOMMON_LIBRARIES}
-  ${LLVFS_LIBRARIES}
+  ${LLFILESYSTEM_LIBRARIES}
   ${LLMATH_LIBRARIES}
   ${JSONCPP_LIBRARIES}
   ${OPENSSL_LIBRARIES}
@@ -257,7 +257,7 @@ if (LL_TESTS)
 if (LINUX)
   set(test_libs
     ${WINDOWS_LIBRARIES}
-    ${LLVFS_LIBRARIES}
+    ${LLFILESYSTEM_LIBRARIES}
     ${LLMATH_LIBRARIES}
     ${CURL_LIBRARIES}
     ${NGHTTP2_LIBRARIES}
@@ -273,7 +273,7 @@ if (LINUX)
 else (LINUX)
   set(test_libs
     ${WINDOWS_LIBRARIES}
-    ${LLVFS_LIBRARIES}
+    ${LLFILESYSTEM_LIBRARIES}
     ${LLMATH_LIBRARIES}
     ${CURL_LIBRARIES}
     ${NGHTTP2_LIBRARIES}
diff --git a/indra/llmessage/llassetstorage.cpp b/indra/llmessage/llassetstorage.cpp
index d7801b6ddc..f38a5e663e 100644
--- a/indra/llmessage/llassetstorage.cpp
+++ b/indra/llmessage/llassetstorage.cpp
@@ -42,8 +42,7 @@
 // this library includes
 #include "message.h"
 #include "llxfermanager.h"
-#include "llvfile.h"
-#include "llvfs.h"
+#include "llfilesystem.h"
 #include "lldbstrings.h"
 
 #include "lltransfersourceasset.h"
@@ -202,7 +201,7 @@ LLBaseDownloadRequest::LLBaseDownloadRequest(const LLUUID &uuid, const LLAssetTy
       mIsTemp(FALSE),
       mIsPriority(FALSE),
       mDataSentInFirstPacket(FALSE),
-      mDataIsInVFS(FALSE)
+      mDataIsInCache(FALSE)
 {
     // Need to guarantee that this time is up to date, we may be creating a circuit even though we haven't been
     //  running a message system loop.
@@ -266,7 +265,8 @@ LLSD LLAssetRequest::getFullDetails() const
     sd["is_local"] = mIsLocal;
     sd["is_priority"] = mIsPriority;
     sd["data_send_in_first_packet"] = mDataSentInFirstPacket;
-    sd["data_is_in_vfs"] = mDataIsInVFS;
+    // Note: cannot change this (easily) since it is consumed by server
+    sd["data_is_in_vfs"] = mDataIsInCache;
 
     return sd;
 }
@@ -330,28 +330,23 @@ LLBaseDownloadRequest* LLEstateAssetRequest::getCopy()
 // TODO: rework tempfile handling?
 
 
-LLAssetStorage::LLAssetStorage(LLMessageSystem *msg, LLXferManager *xfer, LLVFS *vfs, LLVFS *static_vfs, const LLHost &upstream_host)
+LLAssetStorage::LLAssetStorage(LLMessageSystem *msg, LLXferManager *xfer, const LLHost &upstream_host)
 {
-    _init(msg, xfer, vfs, static_vfs, upstream_host);
+    _init(msg, xfer, upstream_host);
 }
 
-LLAssetStorage::LLAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
-                               LLVFS *vfs, LLVFS *static_vfs)
+LLAssetStorage::LLAssetStorage(LLMessageSystem *msg, LLXferManager *xfer)
 {
-    _init(msg, xfer, vfs, static_vfs, LLHost());
+    _init(msg, xfer, LLHost());
 }
 
 void LLAssetStorage::_init(LLMessageSystem *msg,
                            LLXferManager *xfer,
-                           LLVFS *vfs,
-                           LLVFS *static_vfs,
                            const LLHost &upstream_host)
 {
     mShutDown = FALSE;
     mMessageSys = msg;
     mXferManager = xfer;
-    mVFS = vfs;
-    mStaticVFS = static_vfs;
 
     setUpstream(upstream_host);
     msg->setHandlerFuncFast(_PREHASH_AssetUploadComplete, processUploadComplete, (void **)this);
@@ -430,7 +425,7 @@ void LLAssetStorage::_cleanupRequests(BOOL all, S32 error)
         }
         if (tmp->mDownCallback)
         {
-            tmp->mDownCallback(mVFS, tmp->getUUID(), tmp->getType(), tmp->mUserData, error, LLExtStat::NONE);
+            tmp->mDownCallback(tmp->getUUID(), tmp->getType(), tmp->mUserData, error, LLExtStat::NONE);
         }
         if (tmp->mInfoCallback)
         {
@@ -443,10 +438,10 @@ void LLAssetStorage::_cleanupRequests(BOOL all, S32 error)
 
 BOOL LLAssetStorage::hasLocalAsset(const LLUUID &uuid, const LLAssetType::EType type)
 {
-    return mStaticVFS->getExists(uuid, type) || mVFS->getExists(uuid, type);
+    return LLFileSystem::getExists(uuid, type);
 }
 
-bool LLAssetStorage::findInStaticVFSAndInvokeCallback(const LLUUID& uuid, LLAssetType::EType type,
+bool LLAssetStorage::findInCacheAndInvokeCallback(const LLUUID& uuid, LLAssetType::EType type,
                                                       LLGetAssetCallback callback, void *user_data)
 {
     if (user_data)
@@ -455,17 +450,17 @@ bool LLAssetStorage::findInStaticVFSAndInvokeCallback(const LLUUID& uuid, LLAsse
         llassert(callback != NULL);
     }
 
-    BOOL exists = mStaticVFS->getExists(uuid, type);
+    BOOL exists = LLFileSystem::getExists(uuid, type);
     if (exists)
     {
-        LLVFile file(mStaticVFS, uuid, type);
+        LLFileSystem file(uuid, type);
         U32 size = file.getSize();
         if (size > 0)
         {
             // we've already got the file
             if (callback)
             {
-                callback(mStaticVFS, uuid, type, user_data, LL_ERR_NOERR, LLExtStat::VFS_CACHED);
+                callback(uuid, type, user_data, LL_ERR_NOERR, LLExtStat::CACHE_CACHED);
             }
             return true;
         }
@@ -506,7 +501,7 @@ void LLAssetStorage::getAssetData(const LLUUID uuid,
         if (callback)
         {
             add(sFailedDownloadCount, 1);
-            callback(mVFS, uuid, type, user_data, LL_ERR_ASSET_REQUEST_FAILED, LLExtStat::NONE);
+            callback(uuid, type, user_data, LL_ERR_ASSET_REQUEST_FAILED, LLExtStat::NONE);
         }
         return;
     }
@@ -517,20 +512,19 @@ void LLAssetStorage::getAssetData(const LLUUID uuid,
         if (callback)
         {
             add(sFailedDownloadCount, 1);
-            callback(mVFS, uuid, type, user_data, LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE, LLExtStat::NULL_UUID);
+            callback(uuid, type, user_data, LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE, LLExtStat::NULL_UUID);
         }
         return;
     }
 
-    // Try static VFS first.
-    if (findInStaticVFSAndInvokeCallback(uuid,type,callback,user_data))
+    if (findInCacheAndInvokeCallback(uuid,type,callback,user_data))
     {
-        LL_DEBUGS("AssetStorage") << "ASSET_TRACE asset " << uuid << " found in static VFS" << LL_ENDL;
+        LL_DEBUGS("AssetStorage") << "ASSET_TRACE asset " << uuid << " found in cache" << LL_ENDL;
         return;
     }
 
-    BOOL exists = mVFS->getExists(uuid, type);
-    LLVFile file(mVFS, uuid, type);
+    BOOL exists = LLFileSystem::getExists(uuid, type);
+    LLFileSystem file(uuid, type);
     U32 size = exists ? file.getSize() : 0;
 
     if (size > 0)
@@ -540,10 +534,10 @@ void LLAssetStorage::getAssetData(const LLUUID uuid,
         // unless there's a weird error
         if (callback)
         {
-            callback(mVFS, uuid, type, user_data, LL_ERR_NOERR, LLExtStat::VFS_CACHED);
+            callback(uuid, type, user_data, LL_ERR_NOERR, LLExtStat::CACHE_CACHED);
         }
 
-        LL_DEBUGS("AssetStorage") << "ASSET_TRACE asset " << uuid << " found in VFS" << LL_ENDL;
+        LL_DEBUGS("AssetStorage") << "ASSET_TRACE asset " << uuid << " found in cache" << LL_ENDL;
     }
     else
     {
@@ -616,7 +610,7 @@ void LLAssetStorage::removeAndCallbackPendingDownloads(const LLUUID& file_id, LL
             {
                 add(sFailedDownloadCount, 1);
             }
-            tmp->mDownCallback(gAssetStorage->mVFS, callback_id, callback_type, tmp->mUserData, result_code, ext_status);
+            tmp->mDownCallback(callback_id, callback_type, tmp->mUserData, result_code, ext_status);
         }
         delete tmp;
     }
@@ -670,7 +664,7 @@ void LLAssetStorage::downloadCompleteCallback(
     if (LL_ERR_NOERR == result)
     {
         // we might have gotten a zero-size file
-        LLVFile vfile(gAssetStorage->mVFS, callback_id, callback_type);
+        LLFileSystem vfile(callback_id, callback_type);
         if (vfile.getSize() <= 0)
         {
             LL_WARNS("AssetStorage") << "downloadCompleteCallback has non-existent or zero-size asset " << callback_id << LL_ENDL;
@@ -719,19 +713,19 @@ void LLAssetStorage::getEstateAsset(
         if (callback)
         {
             add(sFailedDownloadCount, 1);
-            callback(mVFS, asset_id, atype, user_data, LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE, LLExtStat::NULL_UUID);
+            callback(asset_id, atype, user_data, LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE, LLExtStat::NULL_UUID);
         }
         return;
     }
 
-    // Try static VFS first.
-    if (findInStaticVFSAndInvokeCallback(asset_id,atype,callback,user_data))
+    // Try static first.
+    if (findInCacheAndInvokeCallback(asset_id,atype,callback,user_data))
     {
         return;
     }
     
-    BOOL exists = mVFS->getExists(asset_id, atype);
-    LLVFile file(mVFS, asset_id, atype);
+    BOOL exists = LLFileSystem::getExists(asset_id, atype);
+    LLFileSystem file(asset_id, atype);
     U32 size = exists ? file.getSize() : 0;
 
     if (size > 0)
@@ -741,7 +735,7 @@ void LLAssetStorage::getEstateAsset(
         // unless there's a weird error
         if (callback)
         {
-            callback(mVFS, asset_id, atype, user_data, LL_ERR_NOERR, LLExtStat::VFS_CACHED);
+            callback(asset_id, atype, user_data, LL_ERR_NOERR, LLExtStat::CACHE_CACHED);
         }
     }
     else
@@ -792,7 +786,7 @@ void LLAssetStorage::getEstateAsset(
             if (callback)
             {
                 add(sFailedDownloadCount, 1);
-                callback(mVFS, asset_id, atype, user_data, LL_ERR_CIRCUIT_GONE, LLExtStat::NO_UPSTREAM);
+                callback(asset_id, atype, user_data, LL_ERR_CIRCUIT_GONE, LLExtStat::NO_UPSTREAM);
             }
         }
     }
@@ -824,7 +818,7 @@ void LLAssetStorage::downloadEstateAssetCompleteCallback(
     if (LL_ERR_NOERR == result)
     {
         // we might have gotten a zero-size file
-        LLVFile vfile(gAssetStorage->mVFS, req->getUUID(), req->getAType());
+        LLFileSystem vfile(req->getUUID(), req->getAType());
         if (vfile.getSize() <= 0)
         {
             LL_WARNS("AssetStorage") << "downloadCompleteCallback has non-existent or zero-size asset!" << LL_ENDL;
@@ -838,7 +832,7 @@ void LLAssetStorage::downloadEstateAssetCompleteCallback(
     {
         add(sFailedDownloadCount, 1);
     }
-    req->mDownCallback(gAssetStorage->mVFS, req->getUUID(), req->getAType(), req->mUserData, result, ext_status);
+    req->mDownCallback(req->getUUID(), req->getAType(), req->mUserData, result, ext_status);
 }
 
 void LLAssetStorage::getInvItemAsset(
@@ -861,14 +855,13 @@ void LLAssetStorage::getInvItemAsset(
 
     if(asset_id.notNull())
     {
-        // Try static VFS first.
-        if (findInStaticVFSAndInvokeCallback( asset_id, atype, callback, user_data))
+        if (findInCacheAndInvokeCallback( asset_id, atype, callback, user_data))
         {
             return;
         }
 
-        exists = mVFS->getExists(asset_id, atype);
-        LLVFile file(mVFS, asset_id, atype);
+        exists = LLFileSystem::getExists(asset_id, atype);
+        LLFileSystem file(asset_id, atype);
         size = exists ? file.getSize() : 0;
         if(exists && size < 1)
         {
@@ -885,7 +878,7 @@ void LLAssetStorage::getInvItemAsset(
         // unless there's a weird error
         if (callback)
         {
-            callback(mVFS, asset_id, atype, user_data, LL_ERR_NOERR, LLExtStat::VFS_CACHED);
+            callback(asset_id, atype, user_data, LL_ERR_NOERR, LLExtStat::CACHE_CACHED);
         }
     }
     else
@@ -936,7 +929,7 @@ void LLAssetStorage::getInvItemAsset(
             if (callback)
             {
                 add(sFailedDownloadCount, 1);
-                callback(mVFS, asset_id, atype, user_data, LL_ERR_CIRCUIT_GONE, LLExtStat::NO_UPSTREAM);
+                callback(asset_id, atype, user_data, LL_ERR_CIRCUIT_GONE, LLExtStat::NO_UPSTREAM);
             }
         }
     }
@@ -968,7 +961,7 @@ void LLAssetStorage::downloadInvItemCompleteCallback(
     if (LL_ERR_NOERR == result)
     {
         // we might have gotten a zero-size file
-        LLVFile vfile(gAssetStorage->mVFS, req->getUUID(), req->getType());
+        LLFileSystem vfile(req->getUUID(), req->getType());
         if (vfile.getSize() <= 0)
         {
             LL_WARNS("AssetStorage") << "downloadCompleteCallback has non-existent or zero-size asset!" << LL_ENDL;
@@ -982,7 +975,7 @@ void LLAssetStorage::downloadInvItemCompleteCallback(
     {
         add(sFailedDownloadCount, 1);
     }
-    req->mDownCallback(gAssetStorage->mVFS, req->getUUID(), req->getType(), req->mUserData, result, ext_status);
+    req->mDownCallback(req->getUUID(), req->getType(), req->mUserData, result, ext_status);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1293,7 +1286,7 @@ bool LLAssetStorage::deletePendingRequestImpl(LLAssetStorage::request_list_t* re
         if (req->mDownCallback)
         {
             add(sFailedDownloadCount, 1);
-            req->mDownCallback(mVFS, req->getUUID(), req->getType(), req->mUserData, error, LLExtStat::REQUEST_DROPPED);
+            req->mDownCallback(req->getUUID(), req->getType(), req->mUserData, error, LLExtStat::REQUEST_DROPPED);
         }
         if (req->mInfoCallback)
         {
@@ -1363,8 +1356,7 @@ void LLAssetStorage::getAssetData(const LLUUID uuid,
     {
         LLAssetRequest* tmp = *iter++;
 
-        //void(*const* cbptr)(LLVFS *, const LLUUID &, LLAssetType::EType, void *, S32, LLExtStat) 
-        auto cbptr = tmp->mDownCallback.target<void(*)(LLVFS *, const LLUUID &, LLAssetType::EType, void *, S32, LLExtStat)>();
+        auto cbptr = tmp->mDownCallback.target<void(*)(const LLUUID &, LLAssetType::EType, void *, S32, LLExtStat)>();
 
         if (type == tmp->getType() && 
             uuid == tmp->getUUID() &&
@@ -1389,8 +1381,7 @@ void LLAssetStorage::getAssetData(const LLUUID uuid,
 }
 
 // static
-void LLAssetStorage::legacyGetDataCallback(LLVFS *vfs,
-                                           const LLUUID &uuid, 
+void LLAssetStorage::legacyGetDataCallback(const LLUUID &uuid, 
                                            LLAssetType::EType type,
                                            void *user_data, 
                                            S32 status, 
@@ -1405,7 +1396,7 @@ void LLAssetStorage::legacyGetDataCallback(LLVFS *vfs,
     if ( !status
          && !toxic )
     {
-        LLVFile file(vfs, uuid, type);
+        LLFileSystem file(uuid, type);
 
         std::string uuid_str;
 
diff --git a/indra/llmessage/llassetstorage.h b/indra/llmessage/llassetstorage.h
index 7e4572f50f..274e6a50ad 100644
--- a/indra/llmessage/llassetstorage.h
+++ b/indra/llmessage/llassetstorage.h
@@ -44,7 +44,6 @@
 class LLMessageSystem;
 class LLXferManager;
 class LLAssetStorage;
-class LLVFS;
 class LLSD;
 
 // anything that takes longer than this to download will abort.
@@ -60,11 +59,11 @@ const int LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE = -4;
 const int LL_ERR_INSUFFICIENT_PERMISSIONS = -5;
 const int LL_ERR_PRICE_MISMATCH = -23018;
 
-// *TODO: these typedefs are passed into the VFS via a legacy C function pointer
+// *TODO: these typedefs are passed into the cache via a legacy C function pointer
 // future project would be to convert these to C++ callables (std::function<>) so that 
 // we can use bind and remove the userData parameter.
 // 
-typedef std::function<void(LLVFS *vfs, const LLUUID &asset_id, LLAssetType::EType asset_type, void *user_data, S32 status, LLExtStat ext_status)> LLGetAssetCallback;
+typedef std::function<void(const LLUUID &asset_id, LLAssetType::EType asset_type, void *user_data, S32 status, LLExtStat ext_status)> LLGetAssetCallback;
 typedef std::function<void(const LLUUID &asset_id, void *user_data, S32 status, LLExtStat ext_status)> LLStoreAssetCallback;
 
 
@@ -120,7 +119,6 @@ protected:
 
 public:
     LLGetAssetCallback mDownCallback;
-//    void(*mDownCallback)(LLVFS*, const LLUUID&, LLAssetType::EType, void *, S32, LLExtStat);
 
     void	*mUserData;
     LLHost  mHost;
@@ -128,7 +126,7 @@ public:
     F64Seconds		mTime;				// Message system time
     BOOL    mIsPriority;
     BOOL	mDataSentInFirstPacket;
-    BOOL	mDataIsInVFS;
+    BOOL	mDataIsInCache;
 };
 
 class LLAssetRequest : public LLBaseDownloadRequest
@@ -198,9 +196,6 @@ typedef std::map<LLUUID,U64,lluuid_less> toxic_asset_map_t;
 class LLAssetStorage
 {
 public:
-	// VFS member is public because static child methods need it :(
-	LLVFS *mVFS;
-	LLVFS *mStaticVFS;
     typedef ::LLStoreAssetCallback LLStoreAssetCallback;
     typedef ::LLGetAssetCallback LLGetAssetCallback;
 
@@ -230,11 +225,9 @@ protected:
 	toxic_asset_map_t	mToxicAssetMap;		// Objects in this list are known to cause problems and are not loaded
 
 public:
-	LLAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
-				   LLVFS *vfs, LLVFS *static_vfs, const LLHost &upstream_host);
+	LLAssetStorage(LLMessageSystem *msg, LLXferManager *xfer, const LLHost &upstream_host);
 
-	LLAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
-				   LLVFS *vfs, LLVFS *static_vfs);
+	LLAssetStorage(LLMessageSystem *msg, LLXferManager *xfer);
 	virtual ~LLAssetStorage();
 
 	void setUpstream(const LLHost &upstream_host);
@@ -284,7 +277,7 @@ public:
 	void		markAssetToxic( const LLUUID& uuid );
 
 protected:
-	bool findInStaticVFSAndInvokeCallback(const LLUUID& uuid, LLAssetType::EType type,
+	bool findInCacheAndInvokeCallback(const LLUUID& uuid, LLAssetType::EType type,
 										  LLGetAssetCallback callback, void *user_data);
 
 	LLSD getPendingDetailsImpl(const request_list_t* requests,
@@ -375,7 +368,7 @@ public:
 		bool user_waiting = false,
 		F64Seconds timeout  = LL_ASSET_STORAGE_TIMEOUT) = 0;
 
-	static void legacyGetDataCallback(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType, void *user_data, S32 status, LLExtStat ext_status);
+	static void legacyGetDataCallback(const LLUUID &uuid, LLAssetType::EType, void *user_data, S32 status, LLExtStat ext_status);
 	static void legacyStoreDataCallback(const LLUUID &uuid, void *user_data, S32 status, LLExtStat ext_status);
 
 	// add extra methods to handle metadata
@@ -385,15 +378,12 @@ protected:
 	void _callUploadCallbacks(const LLUUID &uuid, const LLAssetType::EType asset_type, BOOL success, LLExtStat ext_status);
 
 	virtual void _queueDataRequest(const LLUUID& uuid, LLAssetType::EType type, LLGetAssetCallback callback,
-//								   void (*callback)(LLVFS *vfs, const LLUUID&, LLAssetType::EType, void *, S32, LLExtStat),
 								   void *user_data, BOOL duplicate,
 								   BOOL is_priority) = 0;
 
 private:
 	void _init(LLMessageSystem *msg,
 			   LLXferManager *xfer,
-			   LLVFS *vfs,
-			   LLVFS *static_vfs,
 			   const LLHost &upstream_host);
 
 protected:
@@ -408,7 +398,7 @@ protected:
 		MR_FILE_NONEXIST	= 3,	// Old format store call - source file does not exist
 		MR_NO_FILENAME		= 4,	// Old format store call - source filename is NULL/0-length
 		MR_NO_UPSTREAM		= 5,	// Upstream provider is missing
-		MR_VFS_CORRUPTION	= 6		// VFS is corrupt - too-large or mismatched stated/returned sizes
+		MR_CACHE_CORRUPTION	= 6		// cache is corrupt - too-large or mismatched stated/returned sizes
 	};
 
 	static class LLMetrics *metric_recipient;
diff --git a/indra/llmessage/llcorehttputil.cpp b/indra/llmessage/llcorehttputil.cpp
index 0eae6d9826..7031f1aa8c 100644
--- a/indra/llmessage/llcorehttputil.cpp
+++ b/indra/llmessage/llcorehttputil.cpp
@@ -37,7 +37,7 @@
 #include "llsdserialize.h"
 #include "reader.h" // JSON
 #include "writer.h" // JSON
-#include "llvfile.h"
+#include "llfilesystem.h"
 
 #include "message.h" // for getting the port
 
@@ -784,7 +784,7 @@ LLSD HttpCoroutineAdapter::postFileAndSuspend(LLCore::HttpRequest::ptr_t request
     // scoping for our streams so that they go away when we no longer need them.
     {
         LLCore::BufferArrayStream outs(fileData.get());
-        LLVFile vfile(gVFS, assetId, assetType, LLVFile::READ);
+        LLFileSystem vfile(assetId, assetType, LLFileSystem::READ);
 
         S32 fileSize = vfile.getSize();
         U8* fileBuffer;
diff --git a/indra/llmessage/llextendedstatus.h b/indra/llmessage/llextendedstatus.h
index 9923d73c1a..2a53dced80 100644
--- a/indra/llmessage/llextendedstatus.h
+++ b/indra/llmessage/llextendedstatus.h
@@ -1,7 +1,7 @@
 /** 
  * @file llextendedstatus.h
  * @date   August 2007
- * @brief extended status codes for curl/vfs/resident asset storage and delivery
+ * @brief extended status codes for curl/resident asset storage and delivery
  *
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
@@ -32,9 +32,9 @@ enum class LLExtStat: uint32_t
 {
 	// Status provider groups - Top bits indicate which status type it is
 	// Zero is common status code (next section)
-	CURL_RESULT	= 1UL<<30, // serviced by curl - use 1L if we really implement the below
-	RES_RESULT	= 2UL<<30, // serviced by resident copy
-	VFS_RESULT	= 3UL<<30, // serviced by vfs
+	CURL_RESULT	 = 1UL<<30, // serviced by curl - use 1L if we really implement the below
+	RES_RESULT	 = 2UL<<30, // serviced by resident copy
+	CACHE_RESULT = 3UL<<30, // serviced by cache
 
 
 	// Common Status Codes
@@ -54,9 +54,9 @@ enum class LLExtStat: uint32_t
 	// Memory-Resident status codes:
 	// None at present
 
-	// VFS status codes:
-	VFS_CACHED	= VFS_RESULT | 0x0001,
-	VFS_CORRUPT	= VFS_RESULT | 0x0002,
+	// CACHE status codes:
+	CACHE_CACHED	= CACHE_RESULT | 0x0001,
+	CACHE_CORRUPT	= CACHE_RESULT | 0x0002,
 };
 
 
diff --git a/indra/llmessage/lltransfersourceasset.cpp b/indra/llmessage/lltransfersourceasset.cpp
index 80ed3340c6..027283232d 100644
--- a/indra/llmessage/lltransfersourceasset.cpp
+++ b/indra/llmessage/lltransfersourceasset.cpp
@@ -32,7 +32,7 @@
 #include "message.h"
 #include "lldatapacker.h"
 #include "lldir.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
 
 LLTransferSourceAsset::LLTransferSourceAsset(const LLUUID &request_id, const F32 priority) :
 	LLTransferSource(LLTST_ASSET, request_id, priority),
@@ -99,7 +99,7 @@ LLTSCode LLTransferSourceAsset::dataCallback(const S32 packet_id,
 		return LLTS_SKIP;
 	}
 
-	LLVFile vf(gAssetStorage->mVFS, mParams.getAssetID(), mParams.getAssetType(), LLVFile::READ);
+	LLFileSystem vf(mParams.getAssetID(), mParams.getAssetType(), LLFileSystem::READ);
 
 	if (!vf.getSize())
 	{
@@ -171,7 +171,7 @@ BOOL LLTransferSourceAsset::unpackParams(LLDataPacker &dp)
 }
 
 
-void LLTransferSourceAsset::responderCallback(LLVFS *vfs, const LLUUID& uuid, LLAssetType::EType type,
+void LLTransferSourceAsset::responderCallback(const LLUUID& uuid, LLAssetType::EType type,
 											  void *user_data, S32 result, LLExtStat ext_status )
 {
 	LLUUID *tidp = ((LLUUID*) user_data);
@@ -198,7 +198,7 @@ void LLTransferSourceAsset::responderCallback(LLVFS *vfs, const LLUUID& uuid, LL
 	if (LL_ERR_NOERR == result)
 	{
 		// Everything's OK.
-		LLVFile vf(gAssetStorage->mVFS, uuid, type, LLVFile::READ);
+		LLFileSystem vf(uuid, type, LLFileSystem::READ);
 		tsap->mSize = vf.getSize();
 		status = LLTS_OK;
 	}
diff --git a/indra/llmessage/lltransfersourceasset.h b/indra/llmessage/lltransfersourceasset.h
index 3abda83cf8..585e683cb3 100644
--- a/indra/llmessage/lltransfersourceasset.h
+++ b/indra/llmessage/lltransfersourceasset.h
@@ -30,7 +30,7 @@
 #include "lltransfermanager.h"
 #include "llassetstorage.h"
 
-class LLVFile;
+class LLFileSystem;
 
 class LLTransferSourceParamsAsset : public LLTransferSourceParams
 {
@@ -56,7 +56,7 @@ public:
 	LLTransferSourceAsset(const LLUUID &request_id, const F32 priority);
 	virtual ~LLTransferSourceAsset();
 
-	static void responderCallback(LLVFS *vfs, const LLUUID& uuid, LLAssetType::EType type,
+	static void responderCallback(const LLUUID& uuid, LLAssetType::EType type,
 								  void *user_data, S32 result, LLExtStat ext_status );
 protected:
 	/*virtual*/ void initTransfer();
diff --git a/indra/llmessage/lltransfertargetvfile.cpp b/indra/llmessage/lltransfertargetvfile.cpp
index b27f0881e0..f6faadf87f 100644
--- a/indra/llmessage/lltransfertargetvfile.cpp
+++ b/indra/llmessage/lltransfertargetvfile.cpp
@@ -30,7 +30,7 @@
 
 #include "lldatapacker.h"
 #include "llerror.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
 
 //static
 void LLTransferTargetVFile::updateQueue(bool shutdown)
@@ -138,10 +138,9 @@ LLTSCode LLTransferTargetVFile::dataCallback(const S32 packet_id, U8 *in_datap,
 	//LL_INFOS() << "LLTransferTargetFile::dataCallback" << LL_ENDL;
 	//LL_INFOS() << "Packet: " << packet_id << LL_ENDL;
 
-	LLVFile vf(gAssetStorage->mVFS, mTempID, mParams.getAssetType(), LLVFile::APPEND);
+	LLFileSystem vf(mTempID, mParams.getAssetType(), LLFileSystem::APPEND);
 	if (mNeedsCreate)
 	{
-		vf.setMaxSize(mSize);
 		mNeedsCreate = FALSE;
 	}
 
@@ -176,7 +175,7 @@ void LLTransferTargetVFile::completionCallback(const LLTSCode status)
 	  case LLTS_DONE:
 		if (!mNeedsCreate)
 		{
-			LLVFile file(gAssetStorage->mVFS, mTempID, mParams.getAssetType(), LLVFile::WRITE);
+			LLFileSystem file(mTempID, mParams.getAssetType(), LLFileSystem::WRITE);
 			if (!file.rename(mParams.getAssetID(), mParams.getAssetType()))
 			{
 				LL_ERRS() << "LLTransferTargetVFile: rename failed" << LL_ENDL;
@@ -195,7 +194,7 @@ void LLTransferTargetVFile::completionCallback(const LLTSCode status)
 	  {
 		  // We're aborting this transfer, we don't want to keep this file.
 		  LL_WARNS() << "Aborting vfile transfer for " << mParams.getAssetID() << LL_ENDL;
-		  LLVFile vf(gAssetStorage->mVFS, mTempID, mParams.getAssetType(), LLVFile::APPEND);
+		  LLFileSystem vf(mTempID, mParams.getAssetType(), LLFileSystem::APPEND);
 		  vf.remove();
 	  }
 	  break;
diff --git a/indra/llmessage/lltransfertargetvfile.h b/indra/llmessage/lltransfertargetvfile.h
index c819c1e2f2..39a9125f1b 100644
--- a/indra/llmessage/lltransfertargetvfile.h
+++ b/indra/llmessage/lltransfertargetvfile.h
@@ -29,9 +29,9 @@
 
 #include "lltransfermanager.h"
 #include "llassetstorage.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
 
-class LLVFile;
+class LLFileSystem;
 
 // Lame, an S32 for now until I figure out the deal with how we want to do
 // error codes.
diff --git a/indra/llmessage/llxfer_vfile.cpp b/indra/llmessage/llxfer_vfile.cpp
index ddc24342f6..12419b342d 100644
--- a/indra/llmessage/llxfer_vfile.cpp
+++ b/indra/llmessage/llxfer_vfile.cpp
@@ -30,8 +30,7 @@
 #include "lluuid.h"
 #include "llerror.h"
 #include "llmath.h"
-#include "llvfile.h"
-#include "llvfs.h"
+#include "llfilesystem.h"
 #include "lldir.h"
 
 // size of chunks read from/written to disk
@@ -42,13 +41,13 @@ const U32 LL_MAX_XFER_FILE_BUFFER = 65536;
 LLXfer_VFile::LLXfer_VFile ()
 : LLXfer(-1)
 {
-	init(NULL, LLUUID::null, LLAssetType::AT_NONE);
+	init(LLUUID::null, LLAssetType::AT_NONE);
 }
 
-LLXfer_VFile::LLXfer_VFile (LLVFS *vfs, const LLUUID &local_id, LLAssetType::EType type)
+LLXfer_VFile::LLXfer_VFile (const LLUUID &local_id, LLAssetType::EType type)
 : LLXfer(-1)
 {
-	init(vfs, local_id, type);
+	init(local_id, type);
 }
 
 ///////////////////////////////////////////////////////////
@@ -60,10 +59,8 @@ LLXfer_VFile::~LLXfer_VFile ()
 
 ///////////////////////////////////////////////////////////
 
-void LLXfer_VFile::init (LLVFS *vfs, const LLUUID &local_id, LLAssetType::EType type)
+void LLXfer_VFile::init (const LLUUID &local_id, LLAssetType::EType type)
 {
-
-	mVFS = vfs;
 	mLocalID = local_id;
 	mType = type;
 
@@ -82,14 +79,14 @@ void LLXfer_VFile::cleanup ()
 	if (mTempID.notNull() &&
 		mDeleteTempFile)
 	{
-		if (mVFS->getExists(mTempID, mType))
+		if (LLFileSystem::getExists(mTempID, mType))
 		{
-			LLVFile file(mVFS, mTempID, mType, LLVFile::WRITE);
+			LLFileSystem file(mTempID, mType, LLFileSystem::WRITE);
 			file.remove();
 		}
 		else
 		{
-			LL_WARNS("Xfer") << "LLXfer_VFile::cleanup() can't open to delete VFS file " << mTempID << "." << LLAssetType::lookup(mType)		
+			LL_WARNS("Xfer") << "LLXfer_VFile::cleanup() can't open to delete cache file " << mTempID << "." << LLAssetType::lookup(mType)		
 				<< ", mRemoteID is " << mRemoteID << LL_ENDL;
 		}
 	}
@@ -103,7 +100,6 @@ void LLXfer_VFile::cleanup ()
 ///////////////////////////////////////////////////////////
 
 S32 LLXfer_VFile::initializeRequest(U64 xfer_id,
-									LLVFS* vfs,
 									const LLUUID& local_id,
 									const LLUUID& remote_id,
 									LLAssetType::EType type,
@@ -115,7 +111,6 @@ S32 LLXfer_VFile::initializeRequest(U64 xfer_id,
 	
 	mRemoteHost = remote_host;
 
-	mVFS = vfs;
 	mLocalID = local_id;
 	mRemoteID = remote_id;
 	mType = type;
@@ -192,13 +187,13 @@ S32 LLXfer_VFile::startSend (U64 xfer_id, const LLHost &remote_host)
 	
 	delete mVFile;
 	mVFile = NULL;
-	if(mVFS->getExists(mLocalID, mType))
+	if(LLFileSystem::getExists(mLocalID, mType))
 	{
-		mVFile = new LLVFile(mVFS, mLocalID, mType, LLVFile::READ);
+		mVFile = new LLFileSystem(mLocalID, mType, LLFileSystem::READ);
 
 		if (mVFile->getSize() <= 0)
 		{
-			LL_WARNS("Xfer") << "LLXfer_VFile::startSend() VFS file " << mLocalID << "." << LLAssetType::lookup(mType)		
+			LL_WARNS("Xfer") << "LLXfer_VFile::startSend() cache file " << mLocalID << "." << LLAssetType::lookup(mType)		
 				<< " has unexpected file size of " << mVFile->getSize() << LL_ENDL;
 			delete mVFile;
 			mVFile = NULL;
@@ -214,7 +209,7 @@ S32 LLXfer_VFile::startSend (U64 xfer_id, const LLHost &remote_host)
 	}
 	else
 	{
-		LL_WARNS("Xfer") << "LLXfer_VFile::startSend() can't read VFS file " << mLocalID << "." << LLAssetType::lookup(mType) << LL_ENDL;
+		LL_WARNS("Xfer") << "LLXfer_VFile::startSend() can't read cache file " << mLocalID << "." << LLAssetType::lookup(mType) << LL_ENDL;
 		retval = LL_ERR_FILE_NOT_FOUND;
 	}
 
@@ -240,13 +235,13 @@ S32 LLXfer_VFile::reopenFileHandle()
 
 	if (mVFile == NULL)
 	{
-		if (mVFS->getExists(mLocalID, mType))
+		if (LLFileSystem::getExists(mLocalID, mType))
 		{
-			mVFile = new LLVFile(mVFS, mLocalID, mType, LLVFile::READ);
+			mVFile = new LLFileSystem(mLocalID, mType, LLFileSystem::READ);
 		}
 		else
 		{
-			LL_WARNS("Xfer") << "LLXfer_VFile::reopenFileHandle() can't read VFS file " << mLocalID << "." << LLAssetType::lookup(mType) << LL_ENDL;
+			LL_WARNS("Xfer") << "LLXfer_VFile::reopenFileHandle() can't read cache file " << mLocalID << "." << LLAssetType::lookup(mType) << LL_ENDL;
 			retval = LL_ERR_FILE_NOT_FOUND;
 		}
 	}
@@ -265,8 +260,7 @@ void LLXfer_VFile::setXferSize (S32 xfer_size)
 	// It would be nice if LLXFers could tell which end of the pipe they were
 	if (! mVFile)
 	{
-		LLVFile file(mVFS, mTempID, mType, LLVFile::APPEND);
-		file.setMaxSize(xfer_size);
+		LLFileSystem file(mTempID, mType, LLFileSystem::APPEND);
 	}
 }
 
@@ -320,7 +314,7 @@ S32 LLXfer_VFile::flush()
 	S32 retval = 0;
 	if (mBufferLength)
 	{
-		LLVFile file(mVFS, mTempID, mType, LLVFile::APPEND);
+		LLFileSystem file(mTempID, mType, LLFileSystem::APPEND);
 
 		file.write((U8*)mBuffer, mBufferLength);
 			
@@ -340,22 +334,15 @@ S32 LLXfer_VFile::processEOF()
 
 	if (!mCallbackResult)
 	{
-		if (mVFS->getExists(mTempID, mType))
+		if (LLFileSystem::getExists(mTempID, mType))
 		{
-			LLVFile file(mVFS, mTempID, mType, LLVFile::WRITE);
+			LLFileSystem file(mTempID, mType, LLFileSystem::WRITE);
 			if (!file.rename(mLocalID, mType))
 			{
-				LL_WARNS("Xfer") << "VFS rename of temp file failed: unable to rename " << mTempID << " to " << mLocalID << LL_ENDL;
+				LL_WARNS("Xfer") << "Cache rename of temp file failed: unable to rename " << mTempID << " to " << mLocalID << LL_ENDL;
 			}
 			else
-			{					
-				#ifdef VFS_SPAM
-				// Debugging spam
-				LL_INFOS("Xfer") << "VFS rename of temp file done: renamed " << mTempID << " to " << mLocalID 
-					<< " LLVFile size is " << file.getSize()
-					<< LL_ENDL;
-				#endif				
-				
+			{									
 				// Rename worked: the original file is gone.   Clear mDeleteTempFile
 				// so we don't attempt to delete the file in cleanup()
 				mDeleteTempFile = FALSE;
@@ -363,7 +350,7 @@ S32 LLXfer_VFile::processEOF()
 		}
 		else
 		{
-			LL_WARNS("Xfer") << "LLXfer_VFile::processEOF() can't open for renaming VFS file " << mTempID << "." << LLAssetType::lookup(mType) << LL_ENDL;
+			LL_WARNS("Xfer") << "LLXfer_VFile::processEOF() can't open for renaming cache file " << mTempID << "." << LLAssetType::lookup(mType) << LL_ENDL;
 		}
 	}
 
diff --git a/indra/llmessage/llxfer_vfile.h b/indra/llmessage/llxfer_vfile.h
index 5bf9a5cfba..d82bab5f6c 100644
--- a/indra/llmessage/llxfer_vfile.h
+++ b/indra/llmessage/llxfer_vfile.h
@@ -30,8 +30,7 @@
 #include "llxfer.h"
 #include "llassetstorage.h"
 
-class LLVFS;
-class LLVFile;
+class LLFileSystem;
 
 class LLXfer_VFile : public LLXfer
 {
@@ -41,9 +40,7 @@ class LLXfer_VFile : public LLXfer
 	LLUUID mTempID;
 	LLAssetType::EType mType;
 	
-	LLVFile *mVFile;
-
-	LLVFS *mVFS;
+	LLFileSystem *mVFile;
 
 	std::string mName;
 
@@ -51,14 +48,13 @@ class LLXfer_VFile : public LLXfer
 
  public:
 	LLXfer_VFile ();
-	LLXfer_VFile (LLVFS *vfs, const LLUUID &local_id, LLAssetType::EType type);
+	LLXfer_VFile (const LLUUID &local_id, LLAssetType::EType type);
 	virtual ~LLXfer_VFile();
 
-	virtual void init(LLVFS *vfs, const LLUUID &local_id, LLAssetType::EType type);
+	virtual void init(const LLUUID &local_id, LLAssetType::EType type);
 	virtual void cleanup();
 
 	virtual S32 initializeRequest(U64 xfer_id,
-			LLVFS *vfs,
 			const LLUUID &local_id,
 			const LLUUID &remote_id,
 			const LLAssetType::EType type,
diff --git a/indra/llmessage/llxfermanager.cpp b/indra/llmessage/llxfermanager.cpp
index 4cea886c8a..f9b59d7e42 100644
--- a/indra/llmessage/llxfermanager.cpp
+++ b/indra/llmessage/llxfermanager.cpp
@@ -56,9 +56,9 @@ const S32 LL_DEFAULT_MAX_HARD_LIMIT_SIMULTANEOUS_XFERS = 500;
 
 ///////////////////////////////////////////////////////////
 
-LLXferManager::LLXferManager (LLVFS *vfs)
+LLXferManager::LLXferManager ()
 {
-	init(vfs);
+	init();
 }
 
 ///////////////////////////////////////////////////////////
@@ -70,7 +70,7 @@ LLXferManager::~LLXferManager ()
 
 ///////////////////////////////////////////////////////////
 
-void LLXferManager::init (LLVFS *vfs)
+void LLXferManager::init()
 {
 	cleanup();
 
@@ -78,8 +78,6 @@ void LLXferManager::init (LLVFS *vfs)
 	setHardLimitOutgoingXfersPerCircuit(LL_DEFAULT_MAX_HARD_LIMIT_SIMULTANEOUS_XFERS);
 	setMaxIncomingXfers(LL_DEFAULT_MAX_REQUEST_FIFO_XFERS);
 
-	mVFS = vfs;
-
 	// Turn on or off ack throttling
 	mUseAckThrottling = FALSE;
 	setAckThrottleBPS(100000);
@@ -462,7 +460,7 @@ U64 LLXferManager::requestFile(const std::string& local_filename,
 
 void LLXferManager::requestVFile(const LLUUID& local_id,
 								 const LLUUID& remote_id,
-								 LLAssetType::EType type, LLVFS* vfs,
+								 LLAssetType::EType type,
 								 const LLHost& remote_host,
 								 void (*callback)(void**,S32,LLExtStat),
 								 void** user_data,
@@ -508,7 +506,6 @@ void LLXferManager::requestVFile(const LLUUID& local_id,
 
 		addToList(xfer_p, mReceiveList, is_priority);
 		((LLXfer_VFile *)xfer_p)->initializeRequest(getNextID(),
-			vfs,
 			local_id,
 			remote_id,
 			type,
@@ -784,33 +781,17 @@ void LLXferManager::processFileRequest (LLMessageSystem *mesgsys, void ** /*user
 	LLXfer *xferp;
 
 	if (uuid != LLUUID::null)
-	{	// Request for an asset - use a VFS file
+	{	// Request for an asset - use a cache file
 		if(NULL == LLAssetType::lookup(type))
 		{
 			LL_WARNS("Xfer") << "Invalid type for xfer request: " << uuid << ":"
 					<< type_s16 << " to " << mesgsys->getSender() << LL_ENDL;
 			return;
 		}
-			
-		if (! mVFS)
-		{
-			LL_WARNS("Xfer") << "Attempt to send VFile w/o available VFS" << LL_ENDL;
-			return;
-		}
-
-		/* Present in fireengine, not used by viewer
-		if (!validateVFileForTransfer(uuid.asString()))
-		{
-			// it is up to the app sending the file to mark it for expected 
-			// transfer before the request arrives or it will be dropped
-			LL_WARNS("Xfer") << "SECURITY: Unapproved VFile '" << uuid << "'" << LL_ENDL;
-			return;
-		}
-		*/
 
 		LL_INFOS("Xfer") << "starting vfile transfer: " << uuid << "," << LLAssetType::lookup(type) << " to " << mesgsys->getSender() << LL_ENDL;
 
-		xferp = (LLXfer *)new LLXfer_VFile(mVFS, uuid, type);
+		xferp = (LLXfer *)new LLXfer_VFile(uuid, type);
 		if (xferp)
 		{
 			mSendList.push_front(xferp);
@@ -1273,9 +1254,9 @@ void LLXferManager::addToList(LLXfer* xferp, xfer_list_t & xfer_list, BOOL is_pr
 LLXferManager *gXferManager = NULL;
 
 
-void start_xfer_manager(LLVFS *vfs)
+void start_xfer_manager()
 {
-	gXferManager = new LLXferManager(vfs);
+	gXferManager = new LLXferManager();
 }
 
 void cleanup_xfer_manager()
diff --git a/indra/llmessage/llxfermanager.h b/indra/llmessage/llxfermanager.h
index 45ae2ffdd3..f49209bed0 100644
--- a/indra/llmessage/llxfermanager.h
+++ b/indra/llmessage/llxfermanager.h
@@ -35,7 +35,6 @@
 
 //Forward declaration to avoid circular dependencies
 class LLXfer;
-class LLVFS;
 
 #include "llxfer.h"
 #include "message.h"
@@ -72,9 +71,6 @@ public:
 
 class LLXferManager
 {
- private:
-	LLVFS *mVFS;
-
  protected:
 	S32    mMaxOutgoingXfersPerCircuit;
 	S32    mHardLimitOutgoingXfersPerCircuit;	// At this limit, kill off the connection
@@ -111,10 +107,10 @@ class LLXferManager
 	std::multiset<std::string> mExpectedVFileRequests;  // files that are authorized to be downloaded on top of
 
  public:
-	LLXferManager(LLVFS *vfs);
+	LLXferManager();
 	virtual ~LLXferManager();
 
-	virtual void init(LLVFS *vfs);
+	virtual void init();
 	virtual void cleanup();
 
 	void setUseAckThrottling(const BOOL use);
@@ -166,7 +162,7 @@ class LLXferManager
 // vfile requesting
 // .. to vfile
 	virtual void requestVFile(const LLUUID &local_id, const LLUUID& remote_id,
-							  LLAssetType::EType type, LLVFS* vfs,
+							  LLAssetType::EType type,
 							  const LLHost& remote_host,
 							  void (*callback)(void**,S32,LLExtStat), void** user_data,
 							  BOOL is_priority = FALSE);
@@ -213,7 +209,7 @@ class LLXferManager
 extern LLXferManager*	gXferManager;
 
 // initialization and garbage collection
-void start_xfer_manager(LLVFS *vfs);
+void start_xfer_manager();
 void cleanup_xfer_manager();
 
 // message system callbacks
diff --git a/indra/llmessage/message.cpp b/indra/llmessage/message.cpp
index da62bb12e8..19146c64f4 100644
--- a/indra/llmessage/message.cpp
+++ b/indra/llmessage/message.cpp
@@ -46,6 +46,7 @@
 #include "apr_poll.h"
 
 // linden library headers
+#include "llapp.h"
 #include "indra_constants.h"
 #include "lldir.h"
 #include "llerror.h"
diff --git a/indra/llplugin/llpluginclassmedia.cpp b/indra/llplugin/llpluginclassmedia.cpp
index a436452461..6f88232c1d 100644
--- a/indra/llplugin/llpluginclassmedia.cpp
+++ b/indra/llplugin/llpluginclassmedia.cpp
@@ -774,6 +774,15 @@ void LLPluginClassMedia::loadURI(const std::string &uri)
 	sendMessage(message);
 }
 
+void LLPluginClassMedia::executeJavaScript(const std::string &code)
+{
+	LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "execute_javascript");
+
+	message.setValue("code", code);
+
+	sendMessage(message);
+}
+
 const char* LLPluginClassMedia::priorityToString(EPriority priority)
 {
 	const char* result = "UNKNOWN";
@@ -951,6 +960,19 @@ void LLPluginClassMedia::setJavascriptEnabled(const bool enabled)
 	sendMessage(message);
 }
 
+void LLPluginClassMedia::setWebSecurityDisabled(const bool disabled)
+{
+	LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "web_security_disabled");
+	message.setValueBoolean("disabled", disabled);
+	sendMessage(message);
+}
+
+void LLPluginClassMedia::setFileAccessFromFileUrlsEnabled(const bool enabled)
+{
+	LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "file_access_from_file_urls");
+	message.setValueBoolean("enabled", enabled);
+	sendMessage(message);
+}
 
 void LLPluginClassMedia::enableMediaPluginDebugging( bool enable )
 {
diff --git a/indra/llplugin/llpluginclassmedia.h b/indra/llplugin/llpluginclassmedia.h
index a09145cf50..adbb93f789 100644
--- a/indra/llplugin/llpluginclassmedia.h
+++ b/indra/llplugin/llpluginclassmedia.h
@@ -153,6 +153,8 @@ public:
 
 	void loadURI(const std::string &uri);
 	
+	void executeJavaScript(const std::string &code);
+
 	// "Loading" means uninitialized or any state prior to fully running (processing commands)
 	bool isPluginLoading(void) { return mPlugin?mPlugin->isLoading():false; };
 
@@ -213,6 +215,8 @@ public:
 	void	setLanguageCode(const std::string &language_code);
 	void	setPluginsEnabled(const bool enabled);
 	void	setJavascriptEnabled(const bool enabled);
+	void	setWebSecurityDisabled(const bool disabled);
+	void	setFileAccessFromFileUrlsEnabled(const bool enabled);
 	void	setTarget(const std::string &target);
 	
 	///////////////////////////////////
diff --git a/indra/llplugin/llpluginprocessparent.cpp b/indra/llplugin/llpluginprocessparent.cpp
index c39ac815c0..eef22156bc 100644
--- a/indra/llplugin/llpluginprocessparent.cpp
+++ b/indra/llplugin/llpluginprocessparent.cpp
@@ -28,6 +28,7 @@
 
 #include "linden_common.h"
 
+#include "llapp.h"
 #include "llpluginprocessparent.h"
 #include "llpluginmessagepipe.h"
 #include "llpluginmessageclasses.h"
diff --git a/indra/llrender/CMakeLists.txt b/indra/llrender/CMakeLists.txt
index 47e7ad915b..baab09a104 100644
--- a/indra/llrender/CMakeLists.txt
+++ b/indra/llrender/CMakeLists.txt
@@ -9,10 +9,9 @@ include(LLCommon)
 include(LLImage)
 include(LLMath)
 include(LLRender)
-include(LLVFS)
 include(LLWindow)
 include(LLXML)
-include(LLVFS)
+include(LLFileSystem)
 
 include_directories(
     ${FREETYPE_INCLUDE_DIRS}
@@ -20,10 +19,9 @@ include_directories(
     ${LLIMAGE_INCLUDE_DIRS}
     ${LLMATH_INCLUDE_DIRS}
     ${LLRENDER_INCLUDE_DIRS}
-    ${LLVFS_INCLUDE_DIRS}
+    ${LLFILESYSTEM_INCLUDE_DIRS}
     ${LLWINDOW_INCLUDE_DIRS}
     ${LLXML_INCLUDE_DIRS}
-    ${LLVFS_INCLUDE_DIRS}
     )
 include_directories(SYSTEM
     ${LLCOMMON_SYSTEM_INCLUDE_DIRS}
@@ -104,9 +102,8 @@ if (BUILD_HEADLESS)
     ${LLIMAGE_LIBRARIES}
     ${LLMATH_LIBRARIES}
     ${LLRENDER_HEADLESS_LIBRARIES}
-    ${LLVFS_LIBRARIES}
     ${LLXML_LIBRARIES}
-    ${LLVFS_LIBRARIES}
+    ${LLFILESYSTEM_LIBRARIES}
     ${LLWINDOW_HEADLESS_LIBRARIES}
     ${OPENGL_HEADLESS_LIBRARIES})
 
@@ -126,9 +123,8 @@ target_link_libraries(llrender
     ${LLCOMMON_LIBRARIES}
     ${LLIMAGE_LIBRARIES}
     ${LLMATH_LIBRARIES}
-    ${LLVFS_LIBRARIES}
+    ${LLFILESYSTEM_LIBRARIES}
     ${LLXML_LIBRARIES}
-    ${LLVFS_LIBRARIES}
     ${LLWINDOW_LIBRARIES}
     ${FREETYPE_LIBRARIES}
     ${OPENGL_LIBRARIES})
diff --git a/indra/llui/CMakeLists.txt b/indra/llui/CMakeLists.txt
index f781ff4110..d96824bbf8 100644
--- a/indra/llui/CMakeLists.txt
+++ b/indra/llui/CMakeLists.txt
@@ -13,7 +13,7 @@ include(LLCoreHttp)
 include(LLRender)
 include(LLWindow)
 include(LLCoreHttp)
-include(LLVFS)
+include(LLFileSystem)
 include(LLXML)
 
 include_directories(
@@ -25,7 +25,7 @@ include_directories(
     ${LLMESSAGE_INCLUDE_DIRS}
     ${LLRENDER_INCLUDE_DIRS}
     ${LLWINDOW_INCLUDE_DIRS}
-    ${LLVFS_INCLUDE_DIRS}
+    ${LLFILESYSTEM_INCLUDE_DIRS}
     ${LLXML_INCLUDE_DIRS}
     ${LIBS_PREBUILD_DIR}/include/hunspell
     )
@@ -285,7 +285,7 @@ target_link_libraries(llui
     ${LLINVENTORY_LIBRARIES}
     ${LLMESSAGE_LIBRARIES}
     ${LLCOREHTTP_LIBRARIES}
-    ${LLVFS_LIBRARIES}    # ugh, just for LLDir
+    ${LLFILESYSTEM_LIBRARIES}
     ${LLXUIXML_LIBRARIES}
     ${LLXML_LIBRARIES}
     ${LLMATH_LIBRARIES}
diff --git a/indra/llui/llviewereventrecorder.h b/indra/llui/llviewereventrecorder.h
index d1059d55de..94e66f5dc4 100644
--- a/indra/llui/llviewereventrecorder.h
+++ b/indra/llui/llviewereventrecorder.h
@@ -32,7 +32,6 @@
 #include "lldir.h" 
 #include "llsd.h"  
 #include "llfile.h"
-#include "llvfile.h"
 #include "lldate.h"
 #include "llsdserialize.h"
 #include "llkeyboard.h"
diff --git a/indra/llvfs/llpidlock.cpp b/indra/llvfs/llpidlock.cpp
deleted file mode 100644
index f770e93d45..0000000000
--- a/indra/llvfs/llpidlock.cpp
+++ /dev/null
@@ -1,276 +0,0 @@
-/** 
- * @file llformat.cpp
- * @date   January 2007
- * @brief string formatting utility
- *
- * $LicenseInfo:firstyear=2007&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-
-#include "llapr.h" // thread-related functions
-#include "llpidlock.h"
-#include "lldir.h"
-#include "llsd.h"
-#include "llsdserialize.h"
-#include "llnametable.h"
-#include "llframetimer.h"
-
-#if LL_WINDOWS   //For windows platform.
-
-#include <windows.h>
-
-bool isProcessAlive(U32 pid)
-{
-	return (bool) GetProcessVersion((DWORD)pid);
-}
-
-#else   //Everyone Else
-bool isProcessAlive(U32 pid)
-{   
-	return (bool) kill( (pid_t)pid, 0);
-}
-#endif //Everyone else.
-
-
-	
-class LLPidLockFile
-{
-	public:
-		LLPidLockFile( ) :
-			mAutosave(false),
-			mSaving(false),
-			mWaiting(false),
-			mPID(getpid()),
-			mNameTable(NULL),
-			mClean(true)
-		{
-			mLockName = gDirUtilp->getTempDir() + gDirUtilp->getDirDelimiter() + "savelock";
-		}
-		bool requestLock(LLNameTable<void *> *name_table, bool autosave,
-						bool force_immediate=FALSE, F32 timeout=300.0);
-		bool checkLock();
-		void releaseLock();
-
-	private:
-		void writeLockFile(LLSD pids);
-	public:
-		static LLPidLockFile& instance(); // return the singleton black list file
-			 
-		bool mAutosave;
-		bool mSaving;
-		bool mWaiting;
-		LLFrameTimer mTimer;
-		U32  mPID;
-		std::string mLockName;
-		std::string mSaveName;
-		LLSD mPIDS_sd;
-		LLNameTable<void*> *mNameTable;
-		bool mClean;
-};
-
-LLPidLockFile& LLPidLockFile::instance()
-{   
-	static LLPidLockFile the_file;
-	return the_file;
-}
-
-void LLPidLockFile::writeLockFile(LLSD pids)
-{
-	llofstream ofile(mLockName.c_str());
-
-	if (!LLSDSerialize::toXML(pids,ofile))
-	{
-		LL_WARNS() << "Unable to write concurrent save lock file." << LL_ENDL;
-	}
-	ofile.close();
-}
-
-bool LLPidLockFile::requestLock(LLNameTable<void *> *name_table, bool autosave,
-								bool force_immediate, F32 timeout)
-{
-	bool readyToSave = FALSE;
-
-	if (mSaving) return FALSE;	//Bail out if we're currently saving.  Will not queue another save.
-	
-	if (!mWaiting){
-		mNameTable=name_table;
-		mAutosave = autosave;
-	}
-
-	LLSD out_pids;
-	out_pids.append( (LLSD::Integer)mPID );
-
-	llifstream ifile(mLockName.c_str());
-
-	if (ifile.is_open()) 
-	{									//If file exists, we need to decide whether or not to continue.
-		if ( force_immediate
-			|| mTimer.hasExpired() )	//Only deserialize if we REALLY need to.
-		{
-
-			LLSD in_pids;
-
-			LLSDSerialize::fromXML(in_pids, ifile);	
-
-			//Clean up any dead PIDS that might be in there.
-			for (LLSD::array_iterator i=in_pids.beginArray();
-				i !=in_pids.endArray();
-				++i)
-			{
-				U32 stored_pid=(*i).asInteger();
-
-				if (isProcessAlive(stored_pid))
-				{
-					out_pids.append( (*i) );
-				}
-			}
-
-			readyToSave=TRUE;
-		}
-		ifile.close();
-	}
-	else
-	{
-		readyToSave=TRUE;
-	}
-
-	if (!mWaiting)				//Not presently waiting to save.  Queue up.
-	{
-		mTimer.resetWithExpiry(timeout);
-		mWaiting=TRUE;
-	}
-
-	if (readyToSave)
-	{	//Potential race condition won't kill us. Ignore it.
-		writeLockFile(out_pids);
-		mSaving=TRUE;
-	}
-	
-	return readyToSave;
-}
-
-bool LLPidLockFile::checkLock()
-{
-	return mWaiting;
-}
-
-void LLPidLockFile::releaseLock()
-{
-	llifstream ifile(mLockName.c_str());
-	LLSD in_pids;
-	LLSD out_pids;
-	bool write_file=FALSE;
-
-	LLSDSerialize::fromXML(in_pids, ifile);	
-
-	//Clean up this PID and any dead ones.
-	for (LLSD::array_iterator i=in_pids.beginArray();
-		i !=in_pids.endArray();
-		++i)
-	{
-		U32 stored_pid=(*i).asInteger();
-
-		if (stored_pid != mPID && isProcessAlive(stored_pid))
-		{
-			out_pids.append( (*i) );
-			write_file=TRUE;
-		}
-	}
-	ifile.close();
-
-	if (write_file)
-	{
-		writeLockFile(out_pids);
-	}
-	else
-	{
-		unlink(mLockName.c_str());
-	}
-
-	mSaving=FALSE;
-	mWaiting=FALSE;
-}
-
-//LLPidLock
-
-void LLPidLock::initClass() { 
-	(void) LLPidLockFile::instance(); 
-}
-
-bool LLPidLock::checkLock() 
-{
-	return LLPidLockFile::instance().checkLock();
-}
-
-bool LLPidLock::requestLock(LLNameTable<void *> *name_table, bool autosave,
-								bool force_immediate, F32 timeout)
-{
-	return LLPidLockFile::instance().requestLock(name_table,autosave,force_immediate,timeout);
-}
-
-void LLPidLock::releaseLock() 
-{ 
-	return LLPidLockFile::instance().releaseLock(); 
-}
-
-bool LLPidLock::isClean() 
-{ 
-	return LLPidLockFile::instance().mClean; 
-}
-
-//getters
-LLNameTable<void *> * LLPidLock::getNameTable() 
-{ 
-    return LLPidLockFile::instance().mNameTable; 
-}
-
-bool LLPidLock::getAutosave() 
-{ 
-	return LLPidLockFile::instance().mAutosave; 
-}
-
-bool LLPidLock::getClean() 
-{ 
-	return LLPidLockFile::instance().mClean; 
-}
-
-std::string LLPidLock::getSaveName() 
-{ 
-	return LLPidLockFile::instance().mSaveName; 
-}
-
-//setters
-void LLPidLock::setClean(bool clean) 
-{ 
-	LLPidLockFile::instance().mClean=clean; 
-}
-
-void LLPidLock::setSaveName(std::string savename) 
-{ 
-	LLPidLockFile::instance().mSaveName=savename; 
-}
-
-S32 LLPidLock::getPID()
-{
-    return (S32)getpid();
-}
diff --git a/indra/llvfs/llpidlock.h b/indra/llvfs/llpidlock.h
deleted file mode 100644
index 334f26bb29..0000000000
--- a/indra/llvfs/llpidlock.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/** 
- * @file llpidlock.h
- * @brief System information debugging classes.
- *
- * $LicenseInfo:firstyear=2001&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_PIDLOCK_H
-#define LL_PIDLOCK_H
-#include "llnametable.h"
-
-class LLSD;
-class LLFrameTimer;
-
-#if !LL_WINDOWS	//For non-windows platforms.
-#include <signal.h>
-#endif
-
-namespace LLPidLock
-{
-    void initClass(); // { (void) LLPidLockFile::instance(); }
-
-    bool requestLock( LLNameTable<void *> *name_table=NULL, bool autosave=TRUE,
-                     bool force_immediate=FALSE, F32 timeout=300.0);
-    bool checkLock();
-    void releaseLock();
-    bool isClean();
-
-    //getters
-    LLNameTable<void *> * getNameTable();
-    bool getAutosave();
-    bool getClean();
-    std::string getSaveName();
-    S32 getPID();
-
-    //setters
-    void setClean(bool clean);
-    void setSaveName(std::string savename);
-};
-
-#endif // LL_PIDLOCK_H
diff --git a/indra/llvfs/llvfile.cpp b/indra/llvfs/llvfile.cpp
deleted file mode 100644
index b8588e99f4..0000000000
--- a/indra/llvfs/llvfile.cpp
+++ /dev/null
@@ -1,437 +0,0 @@
-/** 
- * @file llvfile.cpp
- * @brief Implementation of virtual file
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-
-#include "llvfile.h"
-
-#include "llerror.h"
-#include "llthread.h"
-#include "lltimer.h"
-#include "llfasttimer.h"
-#include "llmemory.h"
-#include "llvfs.h"
-
-const S32 LLVFile::READ			= 0x00000001;
-const S32 LLVFile::WRITE		= 0x00000002;
-const S32 LLVFile::READ_WRITE	= 0x00000003;  // LLVFile::READ & LLVFile::WRITE
-const S32 LLVFile::APPEND		= 0x00000006;  // 0x00000004 & LLVFile::WRITE
-
-static LLTrace::BlockTimerStatHandle FTM_VFILE_WAIT("VFile Wait");
-
-//----------------------------------------------------------------------------
-LLVFSThread* LLVFile::sVFSThread = NULL;
-BOOL LLVFile::sAllocdVFSThread = FALSE;
-//----------------------------------------------------------------------------
-
-//============================================================================
-
-LLVFile::LLVFile(LLVFS *vfs, const LLUUID &file_id, const LLAssetType::EType file_type, S32 mode)
-{
-	mFileType =	file_type;
-
-	mFileID =	file_id;
-	mPosition = 0;
-	mMode =		mode;
-	mVFS =		vfs;
-
-	mBytesRead = 0;
-	mHandle = LLVFSThread::nullHandle();
-	mPriority = 128.f;
-
-	mVFS->incLock(mFileID, mFileType, VFSLOCK_OPEN);
-}
-
-LLVFile::~LLVFile()
-{
-	if (!isReadComplete())
-	{
-		if (mHandle != LLVFSThread::nullHandle())
-		{
-			if (!(mMode & LLVFile::WRITE))
-			{
-				//LL_WARNS() << "Destroying LLVFile with pending async read/write, aborting..." << LL_ENDL;
-				sVFSThread->setFlags(mHandle, LLVFSThread::FLAG_AUTO_COMPLETE | LLVFSThread::FLAG_ABORT);
-			}
-			else // WRITE
-			{
-				sVFSThread->setFlags(mHandle, LLVFSThread::FLAG_AUTO_COMPLETE);
-			}
-		}
-	}
-	mVFS->decLock(mFileID, mFileType, VFSLOCK_OPEN);
-}
-
-BOOL LLVFile::read(U8 *buffer, S32 bytes, BOOL async, F32 priority)
-{
-	if (! (mMode & READ))
-	{
-		LL_WARNS() << "Attempt to read from file " << mFileID << " opened with mode " << std::hex << mMode << std::dec << LL_ENDL;
-		return FALSE;
-	}
-
-	if (mHandle != LLVFSThread::nullHandle())
-	{
-		LL_WARNS() << "Attempt to read from vfile object " << mFileID << " with pending async operation" << LL_ENDL;
-		return FALSE;
-	}
-	mPriority = priority;
-	
-	BOOL success = TRUE;
-
-	// We can't do a read while there are pending async writes
-	waitForLock(VFSLOCK_APPEND);
-	
-	// *FIX: (?)
-	if (async)
-	{
-		mHandle = sVFSThread->read(mVFS, mFileID, mFileType, buffer, mPosition, bytes, threadPri());
-	}
-	else
-	{
-		// We can't do a read while there are pending async writes on this file
-		mBytesRead = sVFSThread->readImmediate(mVFS, mFileID, mFileType, buffer, mPosition, bytes);
-		mPosition += mBytesRead;
-		if (! mBytesRead)
-		{
-			success = FALSE;
-		}
-	}
-
-	return success;
-}
-
-//static
-U8* LLVFile::readFile(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type, S32* bytes_read)
-{
-	U8 *data;
-	LLVFile file(vfs, uuid, type, LLVFile::READ);
-	S32 file_size = file.getSize();
-	if (file_size == 0)
-	{
-		// File is empty.
-		data = NULL;
-	}
-	else
-	{		
-		data = (U8*) ll_aligned_malloc<16>(file_size);
-		file.read(data, file_size);	/* Flawfinder: ignore */ 
-		
-		if (file.getLastBytesRead() != (S32)file_size)
-		{
-			ll_aligned_free<16>(data);
-			data = NULL;
-			file_size = 0;
-		}
-	}
-	if (bytes_read)
-	{
-		*bytes_read = file_size;
-	}
-	return data;
-}
-	
-void LLVFile::setReadPriority(const F32 priority)
-{
-	mPriority = priority;
-	if (mHandle != LLVFSThread::nullHandle())
-	{
-		sVFSThread->setPriority(mHandle, threadPri());
-	}
-}
-
-BOOL LLVFile::isReadComplete()
-{
-	BOOL res = TRUE;
-	if (mHandle != LLVFSThread::nullHandle())
-	{
-		LLVFSThread::Request* req = (LLVFSThread::Request*)sVFSThread->getRequest(mHandle);
-		LLVFSThread::status_t status = req->getStatus();
-		if (status == LLVFSThread::STATUS_COMPLETE)
-		{
-			mBytesRead = req->getBytesRead();
-			mPosition += mBytesRead;
-			sVFSThread->completeRequest(mHandle);
-			mHandle = LLVFSThread::nullHandle();
-		}
-		else
-		{
-			res = FALSE;
-		}
-	}
-	return res;
-}
-
-S32 LLVFile::getLastBytesRead()
-{
-	return mBytesRead;
-}
-
-BOOL LLVFile::eof()
-{
-	return mPosition >= getSize();
-}
-
-BOOL LLVFile::write(const U8 *buffer, S32 bytes)
-{
-	if (! (mMode & WRITE))
-	{
-		LL_WARNS() << "Attempt to write to file " << mFileID << " opened with mode " << std::hex << mMode << std::dec << LL_ENDL;
-	}
-	if (mHandle != LLVFSThread::nullHandle())
-	{
-		LL_ERRS() << "Attempt to write to vfile object " << mFileID << " with pending async operation" << LL_ENDL;
-		return FALSE;
-	}
-	BOOL success = TRUE;
-	
-	// *FIX: allow async writes? potential problem wit mPosition...
-	if (mMode == APPEND) // all appends are async (but WRITEs are not)
-	{	
-		U8* writebuf = new U8[bytes];
-		memcpy(writebuf, buffer, bytes);
-		S32 offset = -1;
-		mHandle = sVFSThread->write(mVFS, mFileID, mFileType,
-									writebuf, offset, bytes,
-									LLVFSThread::FLAG_AUTO_COMPLETE | LLVFSThread::FLAG_AUTO_DELETE);
-		mHandle = LLVFSThread::nullHandle(); // FLAG_AUTO_COMPLETE means we don't track this
-	}
-	else
-	{
-		// We can't do a write while there are pending reads or writes on this file
-		waitForLock(VFSLOCK_READ);
-		waitForLock(VFSLOCK_APPEND);
-
-		S32 pos = (mMode & APPEND) == APPEND ? -1 : mPosition;
-
-		S32 wrote = sVFSThread->writeImmediate(mVFS, mFileID, mFileType, (U8*)buffer, pos, bytes);
-
-		mPosition += wrote;
-		
-		if (wrote < bytes)
-		{	
-			LL_WARNS() << "Tried to write " << bytes << " bytes, actually wrote " << wrote << LL_ENDL;
-
-			success = FALSE;
-		}
-	}
-	return success;
-}
-
-//static
-BOOL LLVFile::writeFile(const U8 *buffer, S32 bytes, LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type)
-{
-	LLVFile file(vfs, uuid, type, LLVFile::WRITE);
-	file.setMaxSize(bytes);
-	return file.write(buffer, bytes);
-}
-
-BOOL LLVFile::seek(S32 offset, S32 origin)
-{
-	if (mMode == APPEND)
-	{
-		LL_WARNS() << "Attempt to seek on append-only file" << LL_ENDL;
-		return FALSE;
-	}
-
-	if (-1 == origin)
-	{
-		origin = mPosition;
-	}
-
-	S32 new_pos = origin + offset;
-
-	S32 size = getSize(); // Calls waitForLock(VFSLOCK_APPEND)
-
-	if (new_pos > size)
-	{
-		LL_WARNS() << "Attempt to seek past end of file" << LL_ENDL;
-
-		mPosition = size;
-		return FALSE;
-	}
-	else if (new_pos < 0)
-	{
-		LL_WARNS() << "Attempt to seek past beginning of file" << LL_ENDL;
-
-		mPosition = 0;
-		return FALSE;
-	}
-
-	mPosition = new_pos;
-	return TRUE;
-}
-
-S32 LLVFile::tell() const
-{
-	return mPosition;
-}
-
-S32 LLVFile::getSize()
-{
-	waitForLock(VFSLOCK_APPEND);
-	S32 size = mVFS->getSize(mFileID, mFileType);
-
-	return size;
-}
-
-S32 LLVFile::getMaxSize()
-{
-	S32 size = mVFS->getMaxSize(mFileID, mFileType);
-
-	return size;
-}
-
-BOOL LLVFile::setMaxSize(S32 size)
-{
-	if (! (mMode & WRITE))
-	{
-		LL_WARNS() << "Attempt to change size of file " << mFileID << " opened with mode " << std::hex << mMode << std::dec << LL_ENDL;
-
-		return FALSE;
-	}
-
-	if (!mVFS->checkAvailable(size))
-	{
-		//LL_RECORD_BLOCK_TIME(FTM_VFILE_WAIT);
-		S32 count = 0;
-		while (sVFSThread->getPending() > 1000)
-		{
-			if (count % 100 == 0)
-			{
-				LL_INFOS() << "VFS catching up... Pending: " << sVFSThread->getPending() << LL_ENDL;
-			}
-			if (sVFSThread->isPaused())
-			{
-				sVFSThread->update(0);
-			}
-			ms_sleep(10);
-		}
-	}
-	return mVFS->setMaxSize(mFileID, mFileType, size);
-}
-
-BOOL LLVFile::rename(const LLUUID &new_id, const LLAssetType::EType new_type)
-{
-	if (! (mMode & WRITE))
-	{
-		LL_WARNS() << "Attempt to rename file " << mFileID << " opened with mode " << std::hex << mMode << std::dec << LL_ENDL;
-
-		return FALSE;
-	}
-
-	if (mHandle != LLVFSThread::nullHandle())
-	{
-		LL_WARNS() << "Renaming file with pending async read" << LL_ENDL;
-	}
-
-	waitForLock(VFSLOCK_READ);
-	waitForLock(VFSLOCK_APPEND);
-
-	// we need to release / replace our own lock
-	// since the renamed file will inherit locks from the new name
-	mVFS->decLock(mFileID, mFileType, VFSLOCK_OPEN);
-	mVFS->renameFile(mFileID, mFileType, new_id, new_type);
-	mVFS->incLock(new_id, new_type, VFSLOCK_OPEN);
-	
-	mFileID = new_id;
-	mFileType = new_type;
-
-	return TRUE;
-}
-
-BOOL LLVFile::remove()
-{
-// 	LL_INFOS() << "Removing file " << mFileID << LL_ENDL;
-	
-	if (! (mMode & WRITE))
-	{
-		// Leaving paranoia warning just because this should be a very infrequent
-		// operation.
-		LL_WARNS() << "Remove file " << mFileID << " opened with mode " << std::hex << mMode << std::dec << LL_ENDL;
-	}
-
-	if (mHandle != LLVFSThread::nullHandle())
-	{
-		LL_WARNS() << "Removing file with pending async read" << LL_ENDL;
-	}
-	
-	// why not seek back to the beginning of the file too?
-	mPosition = 0;
-
-	waitForLock(VFSLOCK_READ);
-	waitForLock(VFSLOCK_APPEND);
-	mVFS->removeFile(mFileID, mFileType);
-
-	return TRUE;
-}
-
-// static
-void LLVFile::initClass(LLVFSThread* vfsthread)
-{
-	if (!vfsthread)
-	{
-		if (LLVFSThread::sLocal != NULL)
-		{
-			vfsthread = LLVFSThread::sLocal;
-		}
-		else
-		{
-			vfsthread = new LLVFSThread();
-			sAllocdVFSThread = TRUE;
-		}
-	}
-	sVFSThread = vfsthread;
-}
-
-// static
-void LLVFile::cleanupClass()
-{
-	if (sAllocdVFSThread)
-	{
-		delete sVFSThread;
-	}
-	sVFSThread = NULL;
-}
-
-bool LLVFile::isLocked(EVFSLock lock)
-{
-	return mVFS->isLocked(mFileID, mFileType, lock) ? true : false;
-}
-
-void LLVFile::waitForLock(EVFSLock lock)
-{
-	//LL_RECORD_BLOCK_TIME(FTM_VFILE_WAIT);
-	// spin until the lock clears
-	while (isLocked(lock))
-	{
-		if (sVFSThread->isPaused())
-		{
-			sVFSThread->update(0);
-		}
-		ms_sleep(1);
-	}
-}
diff --git a/indra/llvfs/llvfile.h b/indra/llvfs/llvfile.h
deleted file mode 100644
index 7e9d9f73e5..0000000000
--- a/indra/llvfs/llvfile.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/** 
- * @file llvfile.h
- * @brief Definition of virtual file
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLVFILE_H
-#define LL_LLVFILE_H
-
-#include "lluuid.h"
-#include "llassettype.h"
-#include "llvfs.h"
-#include "llvfsthread.h"
-
-class LLVFile
-{
-public:
-	LLVFile(LLVFS *vfs, const LLUUID &file_id, const LLAssetType::EType file_type, S32 mode = LLVFile::READ);
-	~LLVFile();
-
-	BOOL read(U8 *buffer, S32 bytes, BOOL async = FALSE, F32 priority = 128.f);	/* Flawfinder: ignore */ 
-	static U8* readFile(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type, S32* bytes_read = 0);
-	void setReadPriority(const F32 priority);
-	BOOL isReadComplete();
-	S32  getLastBytesRead();
-	BOOL eof();
-
-	BOOL write(const U8 *buffer, S32 bytes);
-	static BOOL writeFile(const U8 *buffer, S32 bytes, LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type);
-	BOOL seek(S32 offset, S32 origin = -1);
-	S32  tell() const;
-
-	S32 getSize();
-	S32 getMaxSize();
-	BOOL setMaxSize(S32 size);
-	BOOL rename(const LLUUID &new_id, const LLAssetType::EType new_type);
-	BOOL remove();
-
-	bool isLocked(EVFSLock lock);
-	void waitForLock(EVFSLock lock);
-	
-	static void initClass(LLVFSThread* vfsthread = NULL);
-	static void cleanupClass();
-	static LLVFSThread* getVFSThread() { return sVFSThread; }
-
-protected:
-	static LLVFSThread* sVFSThread;
-	static BOOL sAllocdVFSThread;
-	U32 threadPri() { return LLVFSThread::PRIORITY_NORMAL + llmin((U32)mPriority,(U32)0xfff); }
-	
-public:
-	static const S32 READ;
-	static const S32 WRITE;
-	static const S32 READ_WRITE;
-	static const S32 APPEND;
-	
-protected:
-	LLAssetType::EType mFileType;
-
-	LLUUID	mFileID;
-	S32		mPosition;
-	S32		mMode;
-	LLVFS	*mVFS;
-	F32		mPriority;
-
-	S32		mBytesRead;
-	LLVFSThread::handle_t mHandle;
-};
-
-#endif
diff --git a/indra/llvfs/llvfs.cpp b/indra/llvfs/llvfs.cpp
deleted file mode 100644
index 2c64bf563e..0000000000
--- a/indra/llvfs/llvfs.cpp
+++ /dev/null
@@ -1,2196 +0,0 @@
-/** 
- * @file llvfs.cpp
- * @brief Implementation of virtual file system
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-
-#include "llvfs.h"
-
-#include <sys/stat.h>
-#include <set>
-#include <map>
-#if LL_WINDOWS
-#include <share.h>
-#else
-#include <sys/file.h>
-#endif
-    
-#include "llstl.h"
-#include "lltimer.h"
-    
-const S32 FILE_BLOCK_MASK = 0x000003FF;	 // 1024-byte blocks
-const S32 VFS_CLEANUP_SIZE = 5242880;  // how much space we free up in a single stroke
-const S32 BLOCK_LENGTH_INVALID = -1;	// mLength for invalid LLVFSFileBlocks
-
-LLVFS *gVFS = NULL;
-
-// internal class definitions
-class LLVFSBlock
-{
-public:
-	LLVFSBlock() 
-	{
-		mLocation = 0;
-		mLength = 0;
-	}
-    
-	LLVFSBlock(U32 loc, S32 size)
-	{
-		mLocation = loc;
-		mLength = size;
-	}
-    
-	static bool locationSortPredicate(
-		const LLVFSBlock* lhs,
-		const LLVFSBlock* rhs)
-	{
-		return lhs->mLocation < rhs->mLocation;
-	}
-
-public:
-	U32 mLocation;
-	S32	mLength;		// allocated block size
-};
-    
-LLVFSFileSpecifier::LLVFSFileSpecifier()
-:	mFileID(),
-	mFileType( LLAssetType::AT_NONE )
-{
-}
-    
-LLVFSFileSpecifier::LLVFSFileSpecifier(const LLUUID &file_id, const LLAssetType::EType file_type)
-{
-	mFileID = file_id;
-	mFileType = file_type;
-}
-    
-bool LLVFSFileSpecifier::operator<(const LLVFSFileSpecifier &rhs) const
-{
-	return (mFileID == rhs.mFileID)
-		? mFileType < rhs.mFileType
-		: mFileID < rhs.mFileID;
-}
-    
-bool LLVFSFileSpecifier::operator==(const LLVFSFileSpecifier &rhs) const
-{
-	return (mFileID == rhs.mFileID && 
-			mFileType == rhs.mFileType);
-}
-    
-    
-class LLVFSFileBlock : public LLVFSBlock, public LLVFSFileSpecifier
-{
-public:
-	LLVFSFileBlock() : LLVFSBlock(), LLVFSFileSpecifier()
-	{
-		init();
-	}
-    
-	LLVFSFileBlock(const LLUUID &file_id, LLAssetType::EType file_type, U32 loc = 0, S32 size = 0)
-		: LLVFSBlock(loc, size), LLVFSFileSpecifier( file_id, file_type )
-	{
-		init();
-	}
-
-	void init()
-	{
-		mSize = 0;
-		mIndexLocation = -1;
-		mAccessTime = (U32)time(NULL);
-
-		for (S32 i = 0; i < (S32)VFSLOCK_COUNT; i++)
-		{
-			mLocks[(EVFSLock)i] = 0;
-		}
-	}
-
-	#ifdef LL_LITTLE_ENDIAN
-	inline void swizzleCopy(void *dst, void *src, int size) { memcpy(dst, src, size); /* Flawfinder: ignore */}
-
-	#else
-	
-	inline U32 swizzle32(U32 x)
-	{
-		return(((x >> 24) & 0x000000FF) | ((x >> 8)  & 0x0000FF00) | ((x << 8)  & 0x00FF0000) |((x << 24) & 0xFF000000));
-	}
-	
-	inline U16 swizzle16(U16 x)
-	{
-		return(	((x >> 8)  & 0x000000FF) | ((x << 8)  & 0x0000FF00) );
-	}
-	
-	inline void swizzleCopy(void *dst, void *src, int size) 
-	{
-		if(size == 4)
-		{
-			((U32*)dst)[0] = swizzle32(((U32*)src)[0]); 
-		}
-		else if(size == 2)
-		{
-			((U16*)dst)[0] = swizzle16(((U16*)src)[0]); 
-		}
-		else
-		{
-			// Perhaps this should assert...
-			memcpy(dst, src, size);	/* Flawfinder: ignore */
-		}
-	}
-	
-	#endif
-
-	void serialize(U8 *buffer)
-	{
-		swizzleCopy(buffer, &mLocation, 4);
-		buffer += 4;
-		swizzleCopy(buffer, &mLength, 4);
-		buffer +=4;
-		swizzleCopy(buffer, &mAccessTime, 4);
-		buffer +=4;
-		memcpy(buffer, &mFileID.mData, 16); /* Flawfinder: ignore */	
-		buffer += 16;
-		S16 temp_type = mFileType;
-		swizzleCopy(buffer, &temp_type, 2);
-		buffer += 2;
-		swizzleCopy(buffer, &mSize, 4);
-	}
-    
-	void deserialize(U8 *buffer, const S32 index_loc)
-	{
-		mIndexLocation = index_loc;
-    
-		swizzleCopy(&mLocation, buffer, 4);
-		buffer += 4;
-		swizzleCopy(&mLength, buffer, 4);
-		buffer += 4;
-		swizzleCopy(&mAccessTime, buffer, 4);
-		buffer += 4;
-		memcpy(&mFileID.mData, buffer, 16);
-		buffer += 16;
-		S16 temp_type;
-		swizzleCopy(&temp_type, buffer, 2);
-		mFileType = (LLAssetType::EType)temp_type;
-		buffer += 2;
-		swizzleCopy(&mSize, buffer, 4);
-	}
-    
-	static BOOL insertLRU(LLVFSFileBlock* const& first,
-						  LLVFSFileBlock* const& second)
-	{
-		return (first->mAccessTime == second->mAccessTime)
-			? *first < *second
-			: first->mAccessTime < second->mAccessTime;
-	}
-    
-public:
-	S32  mSize;
-	S32  mIndexLocation; // location of index entry
-	U32  mAccessTime;
-	BOOL mLocks[VFSLOCK_COUNT]; // number of outstanding locks of each type
-    
-	static const S32 SERIAL_SIZE;
-};
-
-// Helper structure for doing lru w/ stl... is there a simpler way?
-struct LLVFSFileBlock_less
-{
-	bool operator()(LLVFSFileBlock* const& lhs, LLVFSFileBlock* const& rhs) const
-	{
-		return (LLVFSFileBlock::insertLRU(lhs, rhs)) ? true : false;
-	}
-};
-
-
-const S32 LLVFSFileBlock::SERIAL_SIZE = 34;
-     
-
-LLVFS::LLVFS(const std::string& index_filename, const std::string& data_filename, const BOOL read_only, const U32 presize, const BOOL remove_after_crash)
-:	mRemoveAfterCrash(remove_after_crash),
-	mDataFP(NULL),
-	mIndexFP(NULL)
-{
-	mDataMutex = new LLMutex();
-
-	S32 i;
-	for (i = 0; i < VFSLOCK_COUNT; i++)
-	{
-		mLockCounts[i] = 0;
-	}
-	mValid = VFSVALID_OK;
-	mReadOnly = read_only;
-	mIndexFilename = index_filename;
-	mDataFilename = data_filename;
-    
-	const char *file_mode = mReadOnly ? "rb" : "r+b";
-    
-	LL_INFOS("VFS") << "Attempting to open VFS index file " << mIndexFilename << LL_ENDL;
-	LL_INFOS("VFS") << "Attempting to open VFS data file " << mDataFilename << LL_ENDL;
-
-	mDataFP = openAndLock(mDataFilename, file_mode, mReadOnly);
-	if (!mDataFP)
-	{
-		if (mReadOnly)
-		{
-			LL_WARNS("VFS") << "Can't find " << mDataFilename << " to open read-only VFS" << LL_ENDL;
-			mValid = VFSVALID_BAD_CANNOT_OPEN_READONLY;
-			return;
-		}
-
-		mDataFP = openAndLock(mDataFilename, "w+b", FALSE);
-		if (mDataFP)
-		{
-			// Since we're creating this data file, assume any index file is bogus
-			// remove the index, since this vfs is now blank
-			LLFile::remove(mIndexFilename);
-		}
-		else
-		{
-			LL_WARNS("VFS") << "Couldn't open vfs data file " 
-				<< mDataFilename << LL_ENDL;
-			mValid = VFSVALID_BAD_CANNOT_CREATE;
-			return;
-		}
-
-		if (presize)
-		{
-			presizeDataFile(presize);
-		}
-	}
-
-	// Did we leave this file open for writing last time?
-	// If so, close it and start over.
-	if (!mReadOnly && mRemoveAfterCrash)
-	{
-		llstat marker_info;
-		std::string marker = mDataFilename + ".open";
-		if (!LLFile::stat(marker, &marker_info))
-		{
-			// marker exists, kill the lock and the VFS files
-			unlockAndClose(mDataFP);
-			mDataFP = NULL;
-
-			LL_WARNS("VFS") << "VFS: File left open on last run, removing old VFS file " << mDataFilename << LL_ENDL;
-			LLFile::remove(mIndexFilename);
-			LLFile::remove(mDataFilename);
-			LLFile::remove(marker);
-
-			mDataFP = openAndLock(mDataFilename, "w+b", FALSE);
-			if (!mDataFP)
-			{
-				LL_WARNS("VFS") << "Can't open VFS data file in crash recovery" << LL_ENDL;
-				mValid = VFSVALID_BAD_CANNOT_CREATE;
-				return;
-			}
-
-			if (presize)
-			{
-				presizeDataFile(presize);
-			}
-		}
-	}
-
-	// determine the real file size
-	fseek(mDataFP, 0, SEEK_END);
-	U32 data_size = ftell(mDataFP);
-
-	// read the index file
-	// make sure there's at least one file in it too
-	// if not, we'll treat this as a new vfs
-	llstat fbuf;
-	if (! LLFile::stat(mIndexFilename, &fbuf) &&
-		fbuf.st_size >= LLVFSFileBlock::SERIAL_SIZE &&
-		(mIndexFP = openAndLock(mIndexFilename, file_mode, mReadOnly))	// Yes, this is an assignment and not '=='
-		)
-	{	
-		std::vector<U8> buffer(fbuf.st_size);
-    		size_t buf_offset = 0;
-		size_t nread = fread(&buffer[0], 1, fbuf.st_size, mIndexFP);
- 
-		std::vector<LLVFSFileBlock*> files_by_loc;
-		
-		while (buf_offset < nread)
-		{
-			LLVFSFileBlock *block = new LLVFSFileBlock();
-    
-			block->deserialize(&buffer[buf_offset], (S32)buf_offset);
-    
-			// Do sanity check on this block.
-			// Note that this skips zero size blocks, which helps VFS
-			// to heal after some errors. JC
-			if (block->mLength > 0 &&
-				(U32)block->mLength <= data_size &&
-				block->mLocation < data_size &&
-				block->mSize > 0 &&
-				block->mSize <= block->mLength &&
-				block->mFileType >= LLAssetType::AT_NONE &&
-				block->mFileType < LLAssetType::AT_COUNT)
-			{
-				mFileBlocks.insert(fileblock_map::value_type(*block, block));
-				files_by_loc.push_back(block);
-			}
-			else
-			if (block->mLength && block->mSize > 0)
-			{
-				// this is corrupt, not empty
-				LL_WARNS("VFS") << "VFS corruption: " << block->mFileID << " (" << block->mFileType << ") at index " << block->mIndexLocation << " DS: " << data_size << LL_ENDL;
-				LL_WARNS("VFS") << "Length: " << block->mLength << "\tLocation: " << block->mLocation << "\tSize: " << block->mSize << LL_ENDL;
-				LL_WARNS("VFS") << "File has bad data - VFS removed" << LL_ENDL;
-
-				delete block;
-
-				unlockAndClose( mIndexFP );
-				mIndexFP = NULL;
-				LLFile::remove( mIndexFilename );
-
-				unlockAndClose( mDataFP );
-				mDataFP = NULL;
-				LLFile::remove( mDataFilename );
-
-				LL_WARNS("VFS") << "Deleted corrupt VFS files " 
-					<< mDataFilename 
-					<< " and "
-					<< mIndexFilename
-					<< LL_ENDL;
-
-				mValid = VFSVALID_BAD_CORRUPT;
-				return;
-			}
-			else
-			{
-				// this is a null or bad entry, skip it
-				mIndexHoles.push_back(buf_offset);
-    
-				delete block;
-			}
-    
-			buf_offset += LLVFSFileBlock::SERIAL_SIZE;
-		}
-
-		std::sort(
-			files_by_loc.begin(),
-			files_by_loc.end(),
-			LLVFSFileBlock::locationSortPredicate);
-
-		// There are 3 cases that have to be considered.
-		// 1. No blocks
-		// 2. One block.
-		// 3. Two or more blocks.
-		if (!files_by_loc.empty())
-		{
-			// cur walks through the list.
-			std::vector<LLVFSFileBlock*>::iterator cur = files_by_loc.begin();
-			std::vector<LLVFSFileBlock*>::iterator end = files_by_loc.end();
-			LLVFSFileBlock* last_file_block = *cur;
-			
-			// Check to see if there is an empty space before the first file.
-			if (last_file_block->mLocation > 0)
-			{
-				// If so, create a free block.
-				addFreeBlock(new LLVFSBlock(0, last_file_block->mLocation));
-			}
-
-			// Walk through the 2nd+ block.  If there is a free space
-			// between cur_file_block and last_file_block, add it to
-			// the free space collection.  This block will not need to
-			// run in the case there is only one entry in the VFS.
-			++cur;
-			while( cur != end )
-			{
-				LLVFSFileBlock* cur_file_block = *cur;
-
-				// Dupe check on the block
-				if (cur_file_block->mLocation == last_file_block->mLocation
-					&& cur_file_block->mLength == last_file_block->mLength)
-				{
-					LL_WARNS("VFS") << "VFS: removing duplicate entry"
-						<< " at " << cur_file_block->mLocation 
-						<< " length " << cur_file_block->mLength 
-						<< " size " << cur_file_block->mSize
-						<< " ID " << cur_file_block->mFileID 
-						<< " type " << cur_file_block->mFileType 
-						<< LL_ENDL;
-
-					// Duplicate entries.  Nuke them both for safety.
-					mFileBlocks.erase(*cur_file_block);	// remove ID/type entry
-					if (cur_file_block->mLength > 0)
-					{
-						// convert to hole
-						addFreeBlock(
-							new LLVFSBlock(
-								cur_file_block->mLocation,
-								cur_file_block->mLength));
-					}
-					lockData();						// needed for sync()
-					sync(cur_file_block, TRUE);		// remove first on disk
-					sync(last_file_block, TRUE);	// remove last on disk
-					unlockData();					// needed for sync()
-					last_file_block = cur_file_block;
-					++cur;
-					continue;
-				}
-
-				// Figure out where the last block ended.
-				S32 loc = last_file_block->mLocation+last_file_block->mLength;
-
-				// Figure out how much space there is between where
-				// the last block ended and this block begins.
-				S32 length = cur_file_block->mLocation - loc;
-    
-				// Check for more errors...  Seeing if the current
-				// entry and the last entry make sense together.
-				if (length < 0 || loc < 0 || (U32)loc > data_size)
-				{
-					// Invalid VFS
-					unlockAndClose( mIndexFP );
-					mIndexFP = NULL;
-					LLFile::remove( mIndexFilename );
-
-					unlockAndClose( mDataFP );
-					mDataFP = NULL;
-					LLFile::remove( mDataFilename );
-
-					LL_WARNS("VFS") << "VFS: overlapping entries"
-						<< " at " << cur_file_block->mLocation 
-						<< " length " << cur_file_block->mLength 
-						<< " ID " << cur_file_block->mFileID 
-						<< " type " << cur_file_block->mFileType 
-						<< LL_ENDL;
-
-					LL_WARNS("VFS") << "Deleted corrupt VFS files " 
-						<< mDataFilename 
-						<< " and "
-						<< mIndexFilename
-						<< LL_ENDL;
-
-					mValid = VFSVALID_BAD_CORRUPT;
-					return;
-				}
-
-				// we don't want to add empty blocks to the list...
-				if (length > 0)
-				{
-					addFreeBlock(new LLVFSBlock(loc, length));
-				}
-				last_file_block = cur_file_block;
-				++cur;
-			}
-    
-			// also note any empty space at the end
-			U32 loc = last_file_block->mLocation + last_file_block->mLength;
-			if (loc < data_size)
-			{
-				addFreeBlock(new LLVFSBlock(loc, data_size - loc));
-			}
-		}
-		else // There where no blocks in the file.
-		{
-			addFreeBlock(new LLVFSBlock(0, data_size));
-		}
-	}
-	else	// Pre-existing index file wasn't opened
-	{
-		if (mReadOnly)
-		{
-			LL_WARNS("VFS") << "Can't find " << mIndexFilename << " to open read-only VFS" << LL_ENDL;
-			mValid = VFSVALID_BAD_CANNOT_OPEN_READONLY;
-			return;
-		}
-    
-	
-		mIndexFP = openAndLock(mIndexFilename, "w+b", FALSE);
-		if (!mIndexFP)
-		{
-			LL_WARNS("VFS") << "Couldn't open an index file for the VFS, probably a sharing violation!" << LL_ENDL;
-
-			unlockAndClose( mDataFP );
-			mDataFP = NULL;
-			LLFile::remove( mDataFilename );
-			
-			mValid = VFSVALID_BAD_CANNOT_CREATE;
-			return;
-		}
-	
-		// no index file, start from scratch w/ 1GB allocation
-		LLVFSBlock *first_block = new LLVFSBlock(0, data_size ? data_size : 0x40000000);
-		addFreeBlock(first_block);
-	}
-
-	// Open marker file to look for bad shutdowns
-	if (!mReadOnly && mRemoveAfterCrash)
-	{
-		std::string marker = mDataFilename + ".open";
-		LLFILE* marker_fp = LLFile::fopen(marker, "w");	/* Flawfinder: ignore */
-		if (marker_fp)
-		{
-			fclose(marker_fp);
-			marker_fp = NULL;
-		}
-	}
-
-	LL_INFOS("VFS") << "Using VFS index file " << mIndexFilename << LL_ENDL;
-	LL_INFOS("VFS") << "Using VFS data file " << mDataFilename << LL_ENDL;
-
-	mValid = VFSVALID_OK;
-}
-    
-LLVFS::~LLVFS()
-{
-	if (mDataMutex->isLocked())
-	{
-		LL_ERRS("VFS") << "LLVFS destroyed with mutex locked" << LL_ENDL;
-	}
-	
-	unlockAndClose(mIndexFP);
-	mIndexFP = NULL;
-
-	fileblock_map::const_iterator it;
-	for (it = mFileBlocks.begin(); it != mFileBlocks.end(); ++it)
-	{
-		delete (*it).second;
-	}
-	mFileBlocks.clear();
-	
-	mFreeBlocksByLength.clear();
-
-	for_each(mFreeBlocksByLocation.begin(), mFreeBlocksByLocation.end(), DeletePairedPointer());
-	mFreeBlocksByLocation.clear();
-    
-	unlockAndClose(mDataFP);
-	mDataFP = NULL;
-    
-	// Remove marker file
-	if (!mReadOnly && mRemoveAfterCrash)
-	{
-		std::string marker = mDataFilename + ".open";
-		LLFile::remove(marker);
-	}
-
-	delete mDataMutex;
-}
-
-
-// Use this function normally to create LLVFS files.  
-// Will append digits to the end of the filename with multiple re-trys
-// static 
-LLVFS * LLVFS::createLLVFS(const std::string& index_filename, 
-		const std::string& data_filename, 
-		const BOOL read_only, 
-		const U32 presize, 
-		const BOOL remove_after_crash)
-{
-	LLVFS * new_vfs = new LLVFS(index_filename, data_filename, read_only, presize, remove_after_crash);
-
-	if( !new_vfs->isValid() )
-	{	// First name failed, retry with new names
-		std::string retry_vfs_index_name;
-		std::string retry_vfs_data_name;
-		S32 count = 0;
-		while (!new_vfs->isValid() &&
-				count < 256)
-		{	// Append '.<number>' to end of filenames
-			retry_vfs_index_name = index_filename + llformat(".%u",count);
-			retry_vfs_data_name = data_filename + llformat(".%u", count);
-
-			delete new_vfs;	// Delete bad VFS and try again
-			new_vfs = new LLVFS(retry_vfs_index_name, retry_vfs_data_name, read_only, presize, remove_after_crash);
-
-			count++;
-		}
-	}
-
-	if( !new_vfs->isValid() )
-	{
-		delete new_vfs;		// Delete bad VFS
-		new_vfs = NULL;		// Total failure
-	}
-
-	return new_vfs;
-}
-
-
-
-void LLVFS::presizeDataFile(const U32 size)
-{
-	if (!mDataFP)
-	{
-		LL_ERRS() << "LLVFS::presizeDataFile() with no data file open" << LL_ENDL;
-		return;
-	}
-
-	// we're creating this file for the first time, size it
-	fseek(mDataFP, size-1, SEEK_SET);
-	S32 tmp = 0;
-	tmp = (S32)fwrite(&tmp, 1, 1, mDataFP);
-	// fflush(mDataFP);
-
-	// also remove any index, since this vfs is now blank
-	LLFile::remove(mIndexFilename);
-
-	if (tmp)
-	{
-		LL_INFOS() << "Pre-sized VFS data file to " << ftell(mDataFP) << " bytes" << LL_ENDL;
-	}
-	else
-	{
-		LL_WARNS() << "Failed to pre-size VFS data file" << LL_ENDL;
-	}
-}
-
-BOOL LLVFS::getExists(const LLUUID &file_id, const LLAssetType::EType file_type)
-{
-	LLVFSFileBlock *block = NULL;
-		
-	if (!isValid())
-	{
-		LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
-	}
-
-	lockData();
-	
-	LLVFSFileSpecifier spec(file_id, file_type);
-	fileblock_map::iterator it = mFileBlocks.find(spec);
-	if (it != mFileBlocks.end())
-	{
-		block = (*it).second;
-		block->mAccessTime = (U32)time(NULL);
-	}
-
-	BOOL res = (block && block->mLength > 0) ? TRUE : FALSE;
-	
-	unlockData();
-	
-	return res;
-}
-    
-S32	 LLVFS::getSize(const LLUUID &file_id, const LLAssetType::EType file_type)
-{
-	S32 size = 0;
-	
-	if (!isValid())
-	{
-		LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
-
-	}
-
-	lockData();
-	
-	LLVFSFileSpecifier spec(file_id, file_type);
-	fileblock_map::iterator it = mFileBlocks.find(spec);
-	if (it != mFileBlocks.end())
-	{
-		LLVFSFileBlock *block = (*it).second;
-
-		block->mAccessTime = (U32)time(NULL);
-		size = block->mSize;
-	}
-
-	unlockData();
-	
-	return size;
-}
-    
-S32  LLVFS::getMaxSize(const LLUUID &file_id, const LLAssetType::EType file_type)
-{
-	S32 size = 0;
-	
-	if (!isValid())
-	{
-		LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
-	}
-
-	lockData();
-	
-	LLVFSFileSpecifier spec(file_id, file_type);
-	fileblock_map::iterator it = mFileBlocks.find(spec);
-	if (it != mFileBlocks.end())
-	{
-		LLVFSFileBlock *block = (*it).second;
-
-		block->mAccessTime = (U32)time(NULL);
-		size = block->mLength;
-	}
-
-	unlockData();
-
-	return size;
-}
-
-BOOL LLVFS::checkAvailable(S32 max_size)
-{
-	lockData();
-	
-	blocks_length_map_t::iterator iter = mFreeBlocksByLength.lower_bound(max_size); // first entry >= size
-	const BOOL res(iter == mFreeBlocksByLength.end() ? FALSE : TRUE);
-
-	unlockData();
-	
-	return res;
-}
-
-BOOL LLVFS::setMaxSize(const LLUUID &file_id, const LLAssetType::EType file_type, S32 max_size)
-{
-	if (!isValid())
-	{
-		LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
-	}
-	if (mReadOnly)
-	{
-		LL_ERRS() << "Attempt to write to read-only VFS" << LL_ENDL;
-	}
-	if (max_size <= 0)
-	{
-		LL_WARNS() << "VFS: Attempt to assign size " << max_size << " to vfile " << file_id << LL_ENDL;
-		return FALSE;
-	}
-
-	lockData();
-	
-	LLVFSFileSpecifier spec(file_id, file_type);
-	LLVFSFileBlock *block = NULL;
-	fileblock_map::iterator it = mFileBlocks.find(spec);
-	if (it != mFileBlocks.end())
-	{
-		block = (*it).second;
-	}
-    
-	// round all sizes upward to KB increments
-	// SJB: Need to not round for the new texture-pipeline code so we know the correct
-	//      max file size. Need to investigate the potential problems with this...
-	if (file_type != LLAssetType::AT_TEXTURE)
-	{
-		if (max_size & FILE_BLOCK_MASK)
-		{
-			max_size += FILE_BLOCK_MASK;
-			max_size &= ~FILE_BLOCK_MASK;
-		}
-    }
-	
-	if (block && block->mLength > 0)
-	{    
-		block->mAccessTime = (U32)time(NULL);
-    
-		if (max_size == block->mLength)
-		{
-			unlockData();
-			return TRUE;
-		}
-		else if (max_size < block->mLength)
-		{
-			// this file is shrinking
-			LLVFSBlock *free_block = new LLVFSBlock(block->mLocation + max_size, block->mLength - max_size);
-
-			addFreeBlock(free_block);
-    
-			block->mLength = max_size;
-    
-			if (block->mLength < block->mSize)
-			{
-				// JC: Was a warning, but Ian says it's bad.
-				LL_ERRS() << "Truncating virtual file " << file_id << " to " << block->mLength << " bytes" << LL_ENDL;
-				block->mSize = block->mLength;
-			}
-    
-			sync(block);
-			//mergeFreeBlocks();
-
-			unlockData();
-			return TRUE;
-		}
-		else if (max_size > block->mLength)
-		{
-			// this file is growing
-			// first check for an adjacent free block to grow into
-			S32 size_increase = max_size - block->mLength;
-
-			// Find the first free block with and addres > block->mLocation
-			LLVFSBlock *free_block;
-			blocks_location_map_t::iterator iter = mFreeBlocksByLocation.upper_bound(block->mLocation);
-			if (iter != mFreeBlocksByLocation.end())
-			{
-				free_block = iter->second;
-			
-				if (free_block->mLocation == block->mLocation + block->mLength &&
-					free_block->mLength >= size_increase)
-				{
-					// this free block is at the end of the file and is large enough
-
-					// Must call useFreeSpace before sync(), as sync()
-					// unlocks data structures.
-					useFreeSpace(free_block, size_increase);
-					block->mLength += size_increase;
-					sync(block);
-
-					unlockData();
-					return TRUE;
-				}
-			}
-			
-			// no adjecent free block, find one in the list
-			free_block = findFreeBlock(max_size, block);
-    
-			if (free_block)
-			{
-				// Save location where data is going, useFreeSpace will move free_block->mLocation;
-				U32 new_data_location = free_block->mLocation;
-
-				//mark the free block as used so it does not
-				//interfere with other operations such as addFreeBlock
-				useFreeSpace(free_block, max_size);		// useFreeSpace takes ownership (and may delete) free_block
-
-				if (block->mLength > 0)
-				{
-					// create a new free block where this file used to be
-					LLVFSBlock *new_free_block = new LLVFSBlock(block->mLocation, block->mLength);
-
-					addFreeBlock(new_free_block);
-					
-					if (block->mSize > 0)
-					{
-						// move the file into the new block
-						std::vector<U8> buffer(block->mSize);
-						fseek(mDataFP, block->mLocation, SEEK_SET);
-						if (fread(&buffer[0], block->mSize, 1, mDataFP) == 1)
-						{
-							fseek(mDataFP, new_data_location, SEEK_SET);
-							if (fwrite(&buffer[0], block->mSize, 1, mDataFP) != 1)
-							{
-								LL_WARNS() << "Short write" << LL_ENDL;
-							}
-						} else {
-							LL_WARNS() << "Short read" << LL_ENDL;
-						}
-					}
-				}
-    
-				block->mLocation = new_data_location;
-    
-				block->mLength = max_size;
-
-
-				sync(block);
-
-				unlockData();
-				return TRUE;
-			}
-			else
-			{
-				LL_WARNS() << "VFS: No space (" << max_size << ") to resize existing vfile " << file_id << LL_ENDL;
-				//dumpMap();
-				unlockData();
-				dumpStatistics();
-				return FALSE;
-			}
-		}
-	}
-	else
-	{
-		// find a free block in the list
-		LLVFSBlock *free_block = findFreeBlock(max_size);
-    
-		if (free_block)
-		{        
-			if (block)
-			{
-				block->mLocation = free_block->mLocation;
-				block->mLength = max_size;
-			}
-			else
-			{
-				// this file doesn't exist, create it
-				block = new LLVFSFileBlock(file_id, file_type, free_block->mLocation, max_size);
-				mFileBlocks.insert(fileblock_map::value_type(spec, block));
-			}
-
-			// Must call useFreeSpace before sync(), as sync()
-			// unlocks data structures.
-			useFreeSpace(free_block, max_size);
-			block->mAccessTime = (U32)time(NULL);
-
-			sync(block);
-		}
-		else
-		{
-			LL_WARNS() << "VFS: No space (" << max_size << ") for new virtual file " << file_id << LL_ENDL;
-			//dumpMap();
-			unlockData();
-			dumpStatistics();
-			return FALSE;
-		}
-	}
-	unlockData();
-	return TRUE;
-}
-
-
-// WARNING: HERE BE DRAGONS!
-// rename is the weirdest VFS op, because the file moves but the locks don't!
-void LLVFS::renameFile(const LLUUID &file_id, const LLAssetType::EType file_type,
-					   const LLUUID &new_id, const LLAssetType::EType &new_type)
-{
-	if (!isValid())
-	{
-		LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
-	}
-	if (mReadOnly)
-	{
-		LL_ERRS() << "Attempt to write to read-only VFS" << LL_ENDL;
-	}
-
-	lockData();
-	
-	LLVFSFileSpecifier new_spec(new_id, new_type);
-	LLVFSFileSpecifier old_spec(file_id, file_type);
-	
-	fileblock_map::iterator it = mFileBlocks.find(old_spec);
-	if (it != mFileBlocks.end())
-	{
-		LLVFSFileBlock *src_block = (*it).second;
-
-		// this will purge the data but leave the file block in place, w/ locks, if any
-		// WAS: removeFile(new_id, new_type); NOW uses removeFileBlock() to avoid mutex lock recursion
-		fileblock_map::iterator new_it = mFileBlocks.find(new_spec);
-		if (new_it != mFileBlocks.end())
-		{
-			LLVFSFileBlock *new_block = (*new_it).second;
-			removeFileBlock(new_block);
-		}
-		
-		// if there's something in the target location, remove it but inherit its locks
-		it = mFileBlocks.find(new_spec);
-		if (it != mFileBlocks.end())
-		{
-			LLVFSFileBlock *dest_block = (*it).second;
-
-			for (S32 i = 0; i < (S32)VFSLOCK_COUNT; i++)
-			{
-				if(dest_block->mLocks[i])
-				{
-					LL_ERRS() << "Renaming VFS block to a locked file." << LL_ENDL;
-				}
-				dest_block->mLocks[i] = src_block->mLocks[i];
-			}
-			
-			mFileBlocks.erase(new_spec);
-			delete dest_block;
-		}
-
-		src_block->mFileID = new_id;
-		src_block->mFileType = new_type;
-		src_block->mAccessTime = (U32)time(NULL);
-   
-		mFileBlocks.erase(old_spec);
-		mFileBlocks.insert(fileblock_map::value_type(new_spec, src_block));
-
-		sync(src_block);
-	}
-	else
-	{
-		LL_WARNS() << "VFS: Attempt to rename nonexistent vfile " << file_id << ":" << file_type << LL_ENDL;
-	}
-	unlockData();
-}
-
-// mDataMutex must be LOCKED before calling this
-void LLVFS::removeFileBlock(LLVFSFileBlock *fileblock)
-{
-	// convert this into an unsaved, dummy fileblock to preserve locks
-	// a more rubust solution would store the locks in a seperate data structure
-	sync(fileblock, TRUE);
-	
-	if (fileblock->mLength > 0)
-	{
-		// turn this file into an empty block
-		LLVFSBlock *free_block = new LLVFSBlock(fileblock->mLocation, fileblock->mLength);
-		
-		addFreeBlock(free_block);
-	}
-	
-	fileblock->mLocation = 0;
-	fileblock->mSize = 0;
-	fileblock->mLength = BLOCK_LENGTH_INVALID;
-	fileblock->mIndexLocation = -1;
-
-	//mergeFreeBlocks();
-}
-
-void LLVFS::removeFile(const LLUUID &file_id, const LLAssetType::EType file_type)
-{
-	if (!isValid())
-	{
-		LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
-	}
-	if (mReadOnly)
-	{
-		LL_ERRS() << "Attempt to write to read-only VFS" << LL_ENDL;
-	}
-
-    lockData();
-	
-	LLVFSFileSpecifier spec(file_id, file_type);
-	fileblock_map::iterator it = mFileBlocks.find(spec);
-	if (it != mFileBlocks.end())
-	{
-		LLVFSFileBlock *block = (*it).second;
-		removeFileBlock(block);
-	}
-	else
-	{
-		LL_WARNS() << "VFS: attempting to remove nonexistent file " << file_id << " type " << file_type << LL_ENDL;
-	}
-
-	unlockData();
-}
-    
-    
-S32 LLVFS::getData(const LLUUID &file_id, const LLAssetType::EType file_type, U8 *buffer, S32 location, S32 length)
-{
-	S32 bytesread = 0;
-	
-	if (!isValid())
-	{
-		LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
-	}
-	llassert(location >= 0);
-	llassert(length >= 0);
-
-	BOOL do_read = FALSE;
-	
-    lockData();
-	
-	LLVFSFileSpecifier spec(file_id, file_type);
-	fileblock_map::iterator it = mFileBlocks.find(spec);
-	if (it != mFileBlocks.end())
-	{
-		LLVFSFileBlock *block = (*it).second;
-
-		block->mAccessTime = (U32)time(NULL);
-    
-		if (location > block->mSize)
-		{
-			LL_WARNS() << "VFS: Attempt to read location " << location << " in file " << file_id << " of length " << block->mSize << LL_ENDL;
-		}
-		else
-		{
-			if (length > block->mSize - location)
-			{
-				length = block->mSize - location;
-			}
-			location += block->mLocation;
-			do_read = TRUE;
-		}
-	}
-
-	if (do_read)
-	{
-		fseek(mDataFP, location, SEEK_SET);
-		bytesread = (S32)fread(buffer, 1, length, mDataFP);
-	}
-	
-	unlockData();
-
-	return bytesread;
-}
-    
-S32 LLVFS::storeData(const LLUUID &file_id, const LLAssetType::EType file_type, const U8 *buffer, S32 location, S32 length)
-{
-	if (!isValid())
-	{
-		LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
-	}
-	if (mReadOnly)
-	{
-		LL_ERRS() << "Attempt to write to read-only VFS" << LL_ENDL;
-	}
-    
-	llassert(length > 0);
-
-    lockData();
-    
-	LLVFSFileSpecifier spec(file_id, file_type);
-	fileblock_map::iterator it = mFileBlocks.find(spec);
-	if (it != mFileBlocks.end())
-	{
-		LLVFSFileBlock *block = (*it).second;
-
-		S32 in_loc = location;
-		if (location == -1)
-		{
-			location = block->mSize;
-		}
-		llassert(location >= 0);
-		
-		block->mAccessTime = (U32)time(NULL);
-    
-		if (block->mLength == BLOCK_LENGTH_INVALID)
-		{
-			// Block was removed, ignore write
-			LL_WARNS() << "VFS: Attempt to write to invalid block"
-					<< " in file " << file_id 
-					<< " location: " << in_loc
-					<< " bytes: " << length
-					<< LL_ENDL;
-			unlockData();
-			return length;
-		}
-		else if (location > block->mLength)
-		{
-			LL_WARNS() << "VFS: Attempt to write to location " << location 
-					<< " in file " << file_id 
-					<< " type " << S32(file_type)
-					<< " of size " << block->mSize
-					<< " block length " << block->mLength
-					<< LL_ENDL;
-			unlockData();
-			return length;
-		}
-		else
-		{
-			if (length > block->mLength - location )
-			{
-				LL_WARNS() << "VFS: Truncating write to virtual file " << file_id << " type " << S32(file_type) << LL_ENDL;
-				length = block->mLength - location;
-			}
-			U32 file_location = location + block->mLocation;
-			
-			fseek(mDataFP, file_location, SEEK_SET);
-			S32 write_len = (S32)fwrite(buffer, 1, length, mDataFP);
-			if (write_len != length)
-			{
-				LL_WARNS() << llformat("VFS Write Error: %d != %d",write_len,length) << LL_ENDL;
-			}
-			// fflush(mDataFP);
-			
-			if (location + length > block->mSize)
-			{
-				block->mSize = location + write_len;
-				sync(block);
-			}
-			unlockData();
-			
-			return write_len;
-		}
-	}
-	else
-	{
-		unlockData();
-		return 0;
-	}
-}
- 
-void LLVFS::incLock(const LLUUID &file_id, const LLAssetType::EType file_type, EVFSLock lock)
-{
-	lockData();
-
-	LLVFSFileSpecifier spec(file_id, file_type);
-	LLVFSFileBlock *block;
-	
- 	fileblock_map::iterator it = mFileBlocks.find(spec);
-	if (it != mFileBlocks.end())
-	{
-		block = (*it).second;
-	}
-	else
-	{
-		// Create a dummy block which isn't saved
-		block = new LLVFSFileBlock(file_id, file_type, 0, BLOCK_LENGTH_INVALID);
-    	block->mAccessTime = (U32)time(NULL);
-		mFileBlocks.insert(fileblock_map::value_type(spec, block));
-	}
-
-	block->mLocks[lock]++;
-	mLockCounts[lock]++;
-	
-	unlockData();
-}
-
-void LLVFS::decLock(const LLUUID &file_id, const LLAssetType::EType file_type, EVFSLock lock)
-{
-	lockData();
-
-	LLVFSFileSpecifier spec(file_id, file_type);
- 	fileblock_map::iterator it = mFileBlocks.find(spec);
-	if (it != mFileBlocks.end())
-	{
-		LLVFSFileBlock *block = (*it).second;
-
-		if (block->mLocks[lock] > 0)
-		{
-			block->mLocks[lock]--;
-		}
-		else
-		{
-			LL_WARNS() << "VFS: Decrementing zero-value lock " << lock << LL_ENDL;
-		}
-		mLockCounts[lock]--;
-	}
-
-	unlockData();
-}
-
-BOOL LLVFS::isLocked(const LLUUID &file_id, const LLAssetType::EType file_type, EVFSLock lock)
-{
-	lockData();
-	
-	BOOL res = FALSE;
-	
-	LLVFSFileSpecifier spec(file_id, file_type);
- 	fileblock_map::iterator it = mFileBlocks.find(spec);
-	if (it != mFileBlocks.end())
-	{
-		LLVFSFileBlock *block = (*it).second;
-		res = (block->mLocks[lock] > 0);
-	}
-
-	unlockData();
-
-	return res;
-}
-
-//============================================================================
-// protected
-//============================================================================
-
-void LLVFS::eraseBlockLength(LLVFSBlock *block)
-{
-	// find the corresponding map entry in the length map and erase it
-	S32 length = block->mLength;
-	blocks_length_map_t::iterator iter = mFreeBlocksByLength.lower_bound(length);
-	blocks_length_map_t::iterator end = mFreeBlocksByLength.end();
-	bool found_block = false;
-	while(iter != end)
-	{
-		LLVFSBlock *tblock = iter->second;
-		llassert(tblock->mLength == length); // there had -better- be an entry with our length!
-		if (tblock == block)
-		{
-			mFreeBlocksByLength.erase(iter);
-			found_block = true;
-			break;
-		}
-		++iter;
-	}
-	if(!found_block)
-	{
-		LL_ERRS() << "eraseBlock could not find block" << LL_ENDL;
-	}
-}
-
-
-// Remove block from both free lists (by location and by length).
-void LLVFS::eraseBlock(LLVFSBlock *block)
-{
-	eraseBlockLength(block);
-	// find the corresponding map entry in the location map and erase it	
-	U32 location = block->mLocation;
-	llverify(mFreeBlocksByLocation.erase(location) == 1); // we should only have one entry per location.
-}
-
-
-// Add the region specified by block location and length to the free lists.
-// Also incrementally defragment by merging with previous and next free blocks.
-void LLVFS::addFreeBlock(LLVFSBlock *block)
-{
-#if LL_DEBUG
-	size_t dbgcount = mFreeBlocksByLocation.count(block->mLocation);
-	if(dbgcount > 0)
-	{
-		LL_ERRS() << "addFreeBlock called with block already in list" << LL_ENDL;
-	}
-#endif
-
-	// Get a pointer to the next free block (by location).
-	blocks_location_map_t::iterator next_free_it = mFreeBlocksByLocation.lower_bound(block->mLocation);
-
-	// We can merge with previous if it ends at our requested location.
-	LLVFSBlock* prev_block = NULL;
-	bool merge_prev = false;
-	if (next_free_it != mFreeBlocksByLocation.begin())
-	{
-		blocks_location_map_t::iterator prev_free_it = next_free_it;
-		--prev_free_it;
-		prev_block = prev_free_it->second;
-		merge_prev = (prev_block->mLocation + prev_block->mLength == block->mLocation);
-	}
-
-	// We can merge with next if our block ends at the next block's location.
-	LLVFSBlock* next_block = NULL;
-	bool merge_next = false;
-	if (next_free_it != mFreeBlocksByLocation.end())
-	{
-		next_block = next_free_it->second;
-		merge_next = (block->mLocation + block->mLength == next_block->mLocation);
-	}
-
-	if (merge_prev && merge_next)
-	{
-		// LL_INFOS() << "VFS merge BOTH" << LL_ENDL;
-		// Previous block is changing length (a lot), so only need to update length map.
-		// Next block is going away completely. JC
-		eraseBlockLength(prev_block);
-		eraseBlock(next_block);
-		prev_block->mLength += block->mLength + next_block->mLength;
-		mFreeBlocksByLength.insert(blocks_length_map_t::value_type(prev_block->mLength, prev_block));
-		delete block;
-		block = NULL;
-		delete next_block;
-		next_block = NULL;
-	}
-	else if (merge_prev)
-	{
-		// LL_INFOS() << "VFS merge previous" << LL_ENDL;
-		// Previous block is maintaining location, only changing length,
-		// therefore only need to update the length map. JC
-		eraseBlockLength(prev_block);
-		prev_block->mLength += block->mLength;
-		mFreeBlocksByLength.insert(blocks_length_map_t::value_type(prev_block->mLength, prev_block)); // multimap insert
-		delete block;
-		block = NULL;
-	}
-	else if (merge_next)
-	{
-		// LL_INFOS() << "VFS merge next" << LL_ENDL;
-		// Next block is changing both location and length,
-		// so both free lists must update. JC
-		eraseBlock(next_block);
-		next_block->mLocation = block->mLocation;
-		next_block->mLength += block->mLength;
-		// Don't hint here, next_free_it iterator may be invalid.
-		mFreeBlocksByLocation.insert(blocks_location_map_t::value_type(next_block->mLocation, next_block)); // multimap insert
-		mFreeBlocksByLength.insert(blocks_length_map_t::value_type(next_block->mLength, next_block)); // multimap insert			
-		delete block;
-		block = NULL;
-	}
-	else
-	{
-		// Can't merge with other free blocks.
-		// Hint that insert should go near next_free_it.
- 		mFreeBlocksByLocation.insert(next_free_it, blocks_location_map_t::value_type(block->mLocation, block)); // multimap insert
- 		mFreeBlocksByLength.insert(blocks_length_map_t::value_type(block->mLength, block)); // multimap insert
-	}
-}
-
-// Superceeded by new addFreeBlock which does incremental free space merging.
-// Incremental is faster overall.
-//void LLVFS::mergeFreeBlocks()
-//{
-// 	if (!isValid())
-// 	{
-// 		LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
-// 	}
-// 	// TODO: could we optimize this with hints from the calling code?
-// 	blocks_location_map_t::iterator iter = mFreeBlocksByLocation.begin();	
-// 	blocks_location_map_t::iterator end = mFreeBlocksByLocation.end();	
-// 	LLVFSBlock *first_block = iter->second;
-// 	while(iter != end)
-// 	{
-// 		blocks_location_map_t::iterator first_iter = iter; // save for if we do a merge
-// 		if (++iter == end)
-// 			break;
-// 		LLVFSBlock *second_block = iter->second;
-// 		if (first_block->mLocation + first_block->mLength == second_block->mLocation)
-// 		{
-// 			// remove the first block from the length map
-// 			eraseBlockLength(first_block);
-// 			// merge first_block with second_block, since they're adjacent
-// 			first_block->mLength += second_block->mLength;
-// 			// add the first block to the length map (with the new size)
-// 			mFreeBlocksByLength.insert(blocks_length_map_t::value_type(first_block->mLength, first_block)); // multimap insert
-//
-// 			// erase and delete the second block
-// 			eraseBlock(second_block);
-// 			delete second_block;
-//
-// 			// reset iterator
-// 			iter = first_iter; // haven't changed first_block, so corresponding iterator is still valid
-// 			end = mFreeBlocksByLocation.end();
-// 		}
-// 		first_block = second_block;
-// 	}
-//}
-	
-// length bytes from free_block are going to be used (so they are no longer free)
-void LLVFS::useFreeSpace(LLVFSBlock *free_block, S32 length)
-{
-	if (free_block->mLength == length)
-	{
-		eraseBlock(free_block);
-		delete free_block;
-	}
-	else
-	{
-		eraseBlock(free_block);
-  		
-		free_block->mLocation += length;
-		free_block->mLength -= length;
-
-		addFreeBlock(free_block);
-	}
-}
-
-// NOTE! mDataMutex must be LOCKED before calling this
-// sync this index entry out to the index file
-// we need to do this constantly to avoid corruption on viewer crash
-void LLVFS::sync(LLVFSFileBlock *block, BOOL remove)
-{
-	if (!isValid())
-	{
-		LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
-	}
-	if (mReadOnly)
-	{
-		LL_WARNS() << "Attempt to sync read-only VFS" << LL_ENDL;
-		return;
-	}
-	if (block->mLength == BLOCK_LENGTH_INVALID)
-	{
-		// This is a dummy file, don't save
-		return;
-	}
-	if (block->mLength == 0)
-	{
-		LL_ERRS() << "VFS syncing zero-length block" << LL_ENDL;
-	}
-
-    BOOL set_index_to_end = FALSE;
-	long seek_pos = block->mIndexLocation;
-		
-	if (-1 == seek_pos)
-	{
-		if (!mIndexHoles.empty())
-		{
-			seek_pos = mIndexHoles.front();
-			mIndexHoles.pop_front();
-		}
-		else
-		{
-			set_index_to_end = TRUE;
-		}
-	}
-
-    if (set_index_to_end)
-	{
-		// Need fseek/ftell to update the seek_pos and hence data
-		// structures, so can't unlockData() before this.
-		fseek(mIndexFP, 0, SEEK_END);
-		seek_pos = ftell(mIndexFP);
-	}
-	    
-	block->mIndexLocation = seek_pos;
-	if (remove)
-	{
-		mIndexHoles.push_back(seek_pos);
-	}
-
-	U8 buffer[LLVFSFileBlock::SERIAL_SIZE];
-	if (remove)
-	{
-		memset(buffer, 0, LLVFSFileBlock::SERIAL_SIZE);
-	}
-	else
-	{
-		block->serialize(buffer);
-	}
-
-	// If set_index_to_end, file pointer is already at seek_pos
-	// and we don't need to do anything.  Only seek if not at end.
-	if (!set_index_to_end)
-	{
-		fseek(mIndexFP, seek_pos, SEEK_SET);
-	}
-
-	if (fwrite(buffer, LLVFSFileBlock::SERIAL_SIZE, 1, mIndexFP) != 1)
-	{
-		LL_WARNS() << "Short write" << LL_ENDL;
-	}
-
-	// *NOTE:  Why was this commented out?
-	// fflush(mIndexFP);
-	
-	return;
-}
-
-// mDataMutex must be LOCKED before calling this
-// Can initiate LRU-based file removal to make space.
-// The immune file block will not be removed.
-LLVFSBlock *LLVFS::findFreeBlock(S32 size, LLVFSFileBlock *immune)
-{
-	if (!isValid())
-	{
-		LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
-	}
-
-	LLVFSBlock *block = NULL;
-	BOOL have_lru_list = FALSE;
-	
-	typedef std::set<LLVFSFileBlock*, LLVFSFileBlock_less> lru_set;
-	lru_set lru_list;
-    
-	LLTimer timer;
-
-	while (! block)
-	{
-		// look for a suitable free block
-		blocks_length_map_t::iterator iter = mFreeBlocksByLength.lower_bound(size); // first entry >= size
-		if (iter != mFreeBlocksByLength.end())
-			block = iter->second;
-    	
-		// no large enough free blocks, time to clean out some junk
-		if (! block)
-		{
-			// create a list of files sorted by usage time
-			// this is far faster than sorting a linked list
-			if (! have_lru_list)
-			{
-				for (fileblock_map::iterator it = mFileBlocks.begin(); it != mFileBlocks.end(); ++it)
-				{
-					LLVFSFileBlock *tmp = (*it).second;
-
-					if (tmp != immune &&
-						tmp->mLength > 0 &&
-						! tmp->mLocks[VFSLOCK_READ] &&
-						! tmp->mLocks[VFSLOCK_APPEND] &&
-						! tmp->mLocks[VFSLOCK_OPEN])
-					{
-						lru_list.insert(tmp);
-					}
-				}
-				
-				have_lru_list = TRUE;
-			}
-
-			if (lru_list.size() == 0)
-			{
-				// No more files to delete, and still not enough room!
-				LL_WARNS() << "VFS: Can't make " << size << " bytes of free space in VFS, giving up" << LL_ENDL;
-				break;
-			}
-
-			// is the oldest file big enough?  (Should be about half the time)
-			lru_set::iterator it = lru_list.begin();
-			LLVFSFileBlock *file_block = *it;
-			if (file_block->mLength >= size && file_block != immune)
-			{
-				// ditch this file and look again for a free block - should find it
-				// TODO: it'll be faster just to assign the free block and break
-				LL_INFOS() << "LRU: Removing " << file_block->mFileID << ":" << file_block->mFileType << LL_ENDL;
-				lru_list.erase(it);
-				removeFileBlock(file_block);
-				file_block = NULL;
-				continue;
-			}
-
-			
-			LL_INFOS() << "VFS: LRU: Aggressive: " << (S32)lru_list.size() << " files remain" << LL_ENDL;
-			dumpLockCounts();
-			
-			// Now it's time to aggressively make more space
-			// Delete the oldest 5MB of the vfs or enough to hold the file, which ever is larger
-			// This may yield too much free space, but we'll use it up soon enough
-			U32 cleanup_target = (size > VFS_CLEANUP_SIZE) ? size : VFS_CLEANUP_SIZE;
-			U32 cleaned_up = 0;
-		   	for (it = lru_list.begin();
-				 it != lru_list.end() && cleaned_up < cleanup_target;
-				 )
-			{
-				file_block = *it;
-				
-				// TODO: it would be great to be able to batch all these sync() calls
-				// LL_INFOS() << "LRU2: Removing " << file_block->mFileID << ":" << file_block->mFileType << " last accessed" << file_block->mAccessTime << LL_ENDL;
-
-				cleaned_up += file_block->mLength;
-				lru_list.erase(it++);
-				removeFileBlock(file_block);
-				file_block = NULL;
-			}
-			//mergeFreeBlocks();
-		}
-	}
-    
-	F32 time = timer.getElapsedTimeF32();
-	if (time > 0.5f)
-	{
-		LL_WARNS() << "VFS: Spent " << time << " seconds in findFreeBlock!" << LL_ENDL;
-	}
-
-	return block;
-}
-
-//============================================================================
-// public
-//============================================================================
-
-void LLVFS::pokeFiles()
-{
-	if (!isValid())
-	{
-		LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
-	}
-	U32 word;
-	
-	// only write data if we actually read 4 bytes
-	// otherwise we're writing garbage and screwing up the file
-	fseek(mDataFP, 0, SEEK_SET);
-	if (fread(&word, sizeof(word), 1, mDataFP) == 1)
-	{
-		fseek(mDataFP, 0, SEEK_SET);
-		if (fwrite(&word, sizeof(word), 1, mDataFP) != 1)
-		{
-			LL_WARNS() << "Could not write to data file" << LL_ENDL;
-		}
-		fflush(mDataFP);
-	}
-
-	fseek(mIndexFP, 0, SEEK_SET);
-	if (fread(&word, sizeof(word), 1, mIndexFP) == 1)
-	{
-		fseek(mIndexFP, 0, SEEK_SET);
-		if (fwrite(&word, sizeof(word), 1, mIndexFP) != 1)
-		{
-			LL_WARNS() << "Could not write to index file" << LL_ENDL;
-		}
-		fflush(mIndexFP);
-	}
-}
-
-    
-void LLVFS::dumpMap()
-{
-	LL_INFOS() << "Files:" << LL_ENDL;
-	for (fileblock_map::iterator it = mFileBlocks.begin(); it != mFileBlocks.end(); ++it)
-	{
-		LLVFSFileBlock *file_block = (*it).second;
-		LL_INFOS() << "Location: " << file_block->mLocation << "\tLength: " << file_block->mLength << "\t" << file_block->mFileID << "\t" << file_block->mFileType << LL_ENDL;
-	}
-    
-	LL_INFOS() << "Free Blocks:" << LL_ENDL;
-	for (blocks_location_map_t::iterator iter = mFreeBlocksByLocation.begin(),
-			 end = mFreeBlocksByLocation.end();
-		 iter != end; iter++)
-	{
-		LLVFSBlock *free_block = iter->second;
-		LL_INFOS() << "Location: " << free_block->mLocation << "\tLength: " << free_block->mLength << LL_ENDL;
-	}
-}
-    
-// verify that the index file contents match the in-memory file structure
-// Very slow, do not call routinely. JC
-void LLVFS::audit()
-{
-	// Lock the mutex through this whole function.
-	LLMutexLock lock_data(mDataMutex);
-	
-	fflush(mIndexFP);
-
-	fseek(mIndexFP, 0, SEEK_END);
-	size_t index_size = ftell(mIndexFP);
-	fseek(mIndexFP, 0, SEEK_SET);
-    
-	BOOL vfs_corrupt = FALSE;
-	
-	// since we take the address of element 0, we need to have at least one element.
-	std::vector<U8> buffer(llmax<size_t>(index_size,1U));
-
-	if (fread(&buffer[0], 1, index_size, mIndexFP) != index_size)
-	{
-		LL_WARNS() << "Index truncated" << LL_ENDL;
-		vfs_corrupt = TRUE;
-	}
-    
-	size_t buf_offset = 0;
-    
-	std::map<LLVFSFileSpecifier, LLVFSFileBlock*>	found_files;
-	U32 cur_time = (U32)time(NULL);
-
-	std::vector<LLVFSFileBlock*> audit_blocks;
-	while (!vfs_corrupt && buf_offset < index_size)
-	{
-		LLVFSFileBlock *block = new LLVFSFileBlock();
-		audit_blocks.push_back(block);
-		
-		block->deserialize(&buffer[buf_offset], (S32)buf_offset);
-		buf_offset += block->SERIAL_SIZE;
-    
-		// do sanity check on this block
-		if (block->mLength >= 0 &&
-			block->mSize >= 0 &&
-			block->mSize <= block->mLength &&
-			block->mFileType >= LLAssetType::AT_NONE &&
-			block->mFileType < LLAssetType::AT_COUNT &&
-			block->mAccessTime <= cur_time &&
-			block->mFileID != LLUUID::null)
-		{
-			if (mFileBlocks.find(*block) == mFileBlocks.end())
-			{
-				LL_WARNS() << "VFile " << block->mFileID << ":" << block->mFileType << " on disk, not in memory, loc " << block->mIndexLocation << LL_ENDL;
-			}
-			else if (found_files.find(*block) != found_files.end())
-			{
-				std::map<LLVFSFileSpecifier, LLVFSFileBlock*>::iterator it;
-				it = found_files.find(*block);
-				LLVFSFileBlock* dupe = it->second;
-				// try to keep data from being lost
-				unlockAndClose(mIndexFP);
-				mIndexFP = NULL;
-				unlockAndClose(mDataFP);
-				mDataFP = NULL;
-				LL_WARNS() << "VFS: Original block index " << block->mIndexLocation
-					<< " location " << block->mLocation 
-					<< " length " << block->mLength 
-					<< " size " << block->mSize 
-					<< " id " << block->mFileID
-					<< " type " << block->mFileType
-					<< LL_ENDL;
-				LL_WARNS() << "VFS: Duplicate block index " << dupe->mIndexLocation
-					<< " location " << dupe->mLocation 
-					<< " length " << dupe->mLength 
-					<< " size " << dupe->mSize 
-					<< " id " << dupe->mFileID
-					<< " type " << dupe->mFileType
-					<< LL_ENDL;
-				LL_WARNS() << "VFS: Index size " << index_size << LL_ENDL;
-				LL_WARNS() << "VFS: INDEX CORRUPT" << LL_ENDL;
-				vfs_corrupt = TRUE;
-				break;
-			}
-			else
-			{
-				found_files[*block] = block;
-			}
-		}
-		else
-		{
-			if (block->mLength)
-			{
-				LL_WARNS() << "VFile " << block->mFileID << ":" << block->mFileType << " corrupt on disk" << LL_ENDL;
-			}
-			// else this is just a hole
-		}
-	}
-    
-	if (!vfs_corrupt)
-	{
-		for (fileblock_map::iterator it = mFileBlocks.begin(); it != mFileBlocks.end(); ++it)
-		{
-			LLVFSFileBlock* block = (*it).second;
-
-			if (block->mSize > 0)
-			{
-				if (! found_files.count(*block))
-				{
-					LL_WARNS() << "VFile " << block->mFileID << ":" << block->mFileType << " in memory, not on disk, loc " << block->mIndexLocation<< LL_ENDL;
-					fseek(mIndexFP, block->mIndexLocation, SEEK_SET);
-					U8 buf[LLVFSFileBlock::SERIAL_SIZE];
-					if (fread(buf, LLVFSFileBlock::SERIAL_SIZE, 1, mIndexFP) != 1)
-					{
-						LL_WARNS() << "VFile " << block->mFileID
-								<< " gave short read" << LL_ENDL;
-					}
-    			
-					LLVFSFileBlock disk_block;
-					disk_block.deserialize(buf, block->mIndexLocation);
-				
-					LL_WARNS() << "Instead found " << disk_block.mFileID << ":" << block->mFileType << LL_ENDL;
-				}
-				else
-				{
-					block = found_files.find(*block)->second;
-					found_files.erase(*block);
-				}
-			}
-		}
-    
-		for (std::map<LLVFSFileSpecifier, LLVFSFileBlock*>::iterator iter = found_files.begin();
-			 iter != found_files.end(); iter++)
-		{
-			LLVFSFileBlock* block = iter->second;
-			LL_WARNS() << "VFile " << block->mFileID << ":" << block->mFileType << " szie:" << block->mSize << " leftover" << LL_ENDL;
-		}
-    
-		LL_INFOS() << "VFS: audit OK" << LL_ENDL;
-		// mutex released by LLMutexLock() destructor.
-	}
-
-	for_each(audit_blocks.begin(), audit_blocks.end(), DeletePointer());
-	audit_blocks.clear();
-}
-    
-    
-// quick check for uninitialized blocks
-// Slow, do not call in release.
-void LLVFS::checkMem()
-{
-	lockData();
-	
-	for (fileblock_map::iterator it = mFileBlocks.begin(); it != mFileBlocks.end(); ++it)
-	{
-		LLVFSFileBlock *block = (*it).second;
-		llassert(block->mFileType >= LLAssetType::AT_NONE &&
-				 block->mFileType < LLAssetType::AT_COUNT &&
-				 block->mFileID != LLUUID::null);
-    
-		for (std::deque<S32>::iterator iter = mIndexHoles.begin();
-			 iter != mIndexHoles.end(); ++iter)
-		{
-			S32 index_loc = *iter;
-			if (index_loc == block->mIndexLocation)
-			{
-				LL_WARNS() << "VFile block " << block->mFileID << ":" << block->mFileType << " is marked as a hole" << LL_ENDL;
-			}
-		}
-	}
-    
-	LL_INFOS() << "VFS: mem check OK" << LL_ENDL;
-
-	unlockData();
-}
-
-void LLVFS::dumpLockCounts()
-{
-	S32 i;
-	for (i = 0; i < VFSLOCK_COUNT; i++)
-	{
-		LL_INFOS() << "LockType: " << i << ": " << mLockCounts[i] << LL_ENDL;
-	}
-}
-
-void LLVFS::dumpStatistics()
-{
-	lockData();
-	
-	// Investigate file blocks.
-	std::map<S32, S32> size_counts;
-	std::map<U32, S32> location_counts;
-	std::map<LLAssetType::EType, std::pair<S32,S32> > filetype_counts;
-
-	S32 max_file_size = 0;
-	S32 total_file_size = 0;
-	S32 invalid_file_count = 0;
-	for (fileblock_map::iterator it = mFileBlocks.begin(); it != mFileBlocks.end(); ++it)
-	{
-		LLVFSFileBlock *file_block = (*it).second;
-		if (file_block->mLength == BLOCK_LENGTH_INVALID)
-		{
-			invalid_file_count++;
-		}
-		else if (file_block->mLength <= 0)
-		{
-			LL_INFOS() << "Bad file block at: " << file_block->mLocation << "\tLength: " << file_block->mLength << "\t" << file_block->mFileID << "\t" << file_block->mFileType << LL_ENDL;
-			size_counts[file_block->mLength]++;
-			location_counts[file_block->mLocation]++;
-		}
-		else
-		{
-			total_file_size += file_block->mLength;
-		}
-
-		if (file_block->mLength > max_file_size)
-		{
-			max_file_size = file_block->mLength;
-		}
-
-		filetype_counts[file_block->mFileType].first++;
-		filetype_counts[file_block->mFileType].second += file_block->mLength;
-	}
-    
-	for (std::map<S32,S32>::iterator it = size_counts.begin(); it != size_counts.end(); ++it)
-	{
-		S32 size = it->first;
-		S32 size_count = it->second;
-		LL_INFOS() << "Bad files size " << size << " count " << size_count << LL_ENDL;
-	}
-	for (std::map<U32,S32>::iterator it = location_counts.begin(); it != location_counts.end(); ++it)
-	{
-		U32 location = it->first;
-		S32 location_count = it->second;
-		LL_INFOS() << "Bad files location " << location << " count " << location_count << LL_ENDL;
-	}
-
-	// Investigate free list.
-	S32 max_free_size = 0;
-	S32 total_free_size = 0;
-	std::map<S32, S32> free_length_counts;
-	for (blocks_location_map_t::iterator iter = mFreeBlocksByLocation.begin(),
-			 end = mFreeBlocksByLocation.end();
-		 iter != end; iter++)
-	{
-		LLVFSBlock *free_block = iter->second;
-		if (free_block->mLength <= 0)
-		{
-			LL_INFOS() << "Bad free block at: " << free_block->mLocation << "\tLength: " << free_block->mLength << LL_ENDL;
-		}
-		else
-		{
-			LL_INFOS() << "Block: " << free_block->mLocation
-					<< "\tLength: " << free_block->mLength
-					<< "\tEnd: " << free_block->mLocation + free_block->mLength
-					<< LL_ENDL;
-			total_free_size += free_block->mLength;
-		}
-
-		if (free_block->mLength > max_free_size)
-		{
-			max_free_size = free_block->mLength;
-		}
-
-		free_length_counts[free_block->mLength]++;
-	}
-
-	// Dump histogram of free block sizes
-	for (std::map<S32,S32>::iterator it = free_length_counts.begin(); it != free_length_counts.end(); ++it)
-	{
-		LL_INFOS() << "Free length " << it->first << " count " << it->second << LL_ENDL;
-	}
-
-	LL_INFOS() << "Invalid blocks: " << invalid_file_count << LL_ENDL;
-	LL_INFOS() << "File blocks:    " << mFileBlocks.size() << LL_ENDL;
-
-	S32 length_list_count = (S32)mFreeBlocksByLength.size();
-	S32 location_list_count = (S32)mFreeBlocksByLocation.size();
-	if (length_list_count == location_list_count)
-	{
-		LL_INFOS() << "Free list lengths match, free blocks: " << location_list_count << LL_ENDL;
-	}
-	else
-	{
-		LL_WARNS() << "Free list lengths do not match!" << LL_ENDL;
-		LL_WARNS() << "By length: " << length_list_count << LL_ENDL;
-		LL_WARNS() << "By location: " << location_list_count << LL_ENDL;
-	}
-	LL_INFOS() << "Max file: " << max_file_size/1024 << "K" << LL_ENDL;
-	LL_INFOS() << "Max free: " << max_free_size/1024 << "K" << LL_ENDL;
-	LL_INFOS() << "Total file size: " << total_file_size/1024 << "K" << LL_ENDL;
-	LL_INFOS() << "Total free size: " << total_free_size/1024 << "K" << LL_ENDL;
-	LL_INFOS() << "Sum: " << (total_file_size + total_free_size) << " bytes" << LL_ENDL;
-	LL_INFOS() << llformat("%.0f%% full",((F32)(total_file_size)/(F32)(total_file_size+total_free_size))*100.f) << LL_ENDL;
-
-	LL_INFOS() << " " << LL_ENDL;
-	for (std::map<LLAssetType::EType, std::pair<S32,S32> >::iterator iter = filetype_counts.begin();
-		 iter != filetype_counts.end(); ++iter)
-	{
-		LL_INFOS() << "Type: " << LLAssetType::getDesc(iter->first)
-				<< " Count: " << iter->second.first
-				<< " Bytes: " << (iter->second.second>>20) << " MB" << LL_ENDL;
-	}
-	
-	// Look for potential merges 
-	{
- 		blocks_location_map_t::iterator iter = mFreeBlocksByLocation.begin();	
- 		blocks_location_map_t::iterator end = mFreeBlocksByLocation.end();	
- 		LLVFSBlock *first_block = iter->second;
- 		while(iter != end)
- 		{
- 			if (++iter == end)
- 				break;
- 			LLVFSBlock *second_block = iter->second;
- 			if (first_block->mLocation + first_block->mLength == second_block->mLocation)
- 			{
-				LL_INFOS() << "Potential merge at " << first_block->mLocation << LL_ENDL;
- 			}
- 			first_block = second_block;
- 		}
-	}
-	unlockData();
-}
-
-// Debug Only!
-std::string get_extension(LLAssetType::EType type)
-{
-	std::string extension;
-	switch(type)
-	{
-	case LLAssetType::AT_TEXTURE:
-		extension = ".jp2";	// formerly ".j2c"
-		break;
-	case LLAssetType::AT_SOUND:
-		extension = ".ogg";
-		break;
-	case LLAssetType::AT_SOUND_WAV:
-		extension = ".wav";
-		break;
-	case LLAssetType::AT_TEXTURE_TGA:
-		extension = ".tga";
-		break;
-	case LLAssetType::AT_ANIMATION:
-		extension = ".lla";
-		break;
-	case LLAssetType::AT_MESH:
-		extension = ".slm";
-		break;
-	default:
-		// Just use the asset server filename extension in most cases
-		extension += ".";
-		extension += LLAssetType::lookup(type);
-		break;
-	}
-	return extension;
-}
-
-void LLVFS::listFiles()
-{
-	lockData();
-	
-	for (fileblock_map::iterator it = mFileBlocks.begin(); it != mFileBlocks.end(); ++it)
-	{
-		LLVFSFileSpecifier file_spec = it->first;
-		LLVFSFileBlock *file_block = it->second;
-		S32 length = file_block->mLength;
-		S32 size = file_block->mSize;
-		if (length != BLOCK_LENGTH_INVALID && size > 0)
-		{
-			LLUUID id = file_spec.mFileID;
-			std::string extension = get_extension(file_spec.mFileType);
-			LL_INFOS() << " File: " << id
-					<< " Type: " << LLAssetType::getDesc(file_spec.mFileType)
-					<< " Size: " << size
-					<< LL_ENDL;
-		}
-	}
-	
-	unlockData();
-}
-
-#include "llapr.h"
-void LLVFS::dumpFiles()
-{
-	lockData();
-	
-	S32 files_extracted = 0;
-	for (fileblock_map::iterator it = mFileBlocks.begin(); it != mFileBlocks.end(); ++it)
-	{
-		LLVFSFileSpecifier file_spec = it->first;
-		LLVFSFileBlock *file_block = it->second;
-		S32 length = file_block->mLength;
-		S32 size = file_block->mSize;
-		if (length != BLOCK_LENGTH_INVALID && size > 0)
-		{
-			LLUUID id = file_spec.mFileID;
-			LLAssetType::EType type = file_spec.mFileType;
-			std::vector<U8> buffer(size);
-
-			unlockData();
-			getData(id, type, &buffer[0], 0, size);
-			lockData();
-			
-			std::string extension = get_extension(type);
-			std::string filename = id.asString() + extension;
-			LL_INFOS() << " Writing " << filename << LL_ENDL;
-			
-			LLAPRFile outfile;
-			outfile.open(filename, LL_APR_WB);
-			outfile.write(&buffer[0], size);
-			outfile.close();
-
-			files_extracted++;
-		}
-	}
-	
-	unlockData();
-
-	LL_INFOS() << "Extracted " << files_extracted << " files out of " << mFileBlocks.size() << LL_ENDL;
-}
-
-time_t LLVFS::creationTime()
-{
-    llstat data_file_stat;
-    int errors = LLFile::stat(mDataFilename, &data_file_stat);
-    if (0 == errors)
-    {
-        time_t creation_time = data_file_stat.st_ctime;
-#if LL_DARWIN
-        creation_time = data_file_stat.st_birthtime;
-#endif
-        return creation_time;
-    }
-    return 0;
-}
-
-//============================================================================
-// protected
-//============================================================================
-
-// static
-LLFILE *LLVFS::openAndLock(const std::string& filename, const char* mode, BOOL read_lock)
-{
-#if LL_WINDOWS
-    	
-	return LLFile::_fsopen(filename, mode, (read_lock ? _SH_DENYWR : _SH_DENYRW));
-    	
-#else
-
-	LLFILE *fp;
-	int fd;
-	
-	// first test the lock in a non-destructive way
-	if (strchr(mode, 'w') != NULL)
-	{
-		fp = LLFile::fopen(filename, "rb");	/* Flawfinder: ignore */
-		if (fp)
-		{
-			fd = fileno(fp);
-			if (flock(fd, (read_lock ? LOCK_SH : LOCK_EX) | LOCK_NB) == -1)
-			{
-				fclose(fp);
-				return NULL;
-			}
-		  
-			fclose(fp);
-		}
-	}
-
-	// now actually open the file for use
-	fp = LLFile::fopen(filename, mode);	/* Flawfinder: ignore */
-	if (fp)
-	{
-		fd = fileno(fp);
-		if (flock(fd, (read_lock ? LOCK_SH : LOCK_EX) | LOCK_NB) == -1)
-		{
-			fclose(fp);
-			fp = NULL;
-		}
-	}
-
-	return fp;
-    	
-#endif
-}
-    
-// static
-void LLVFS::unlockAndClose(LLFILE *fp)
-{
-	if (fp)
-	{
-	// IW: we don't actually want to unlock on linux
-	// this is because a forked process can kill the parent's lock
-	// with an explicit unlock
-	// however, fclose() will implicitly remove the lock
-	// but only once both parent and child have closed the file
-    /*	
-	  #if !LL_WINDOWS
-	  int fd = fileno(fp);
-	  flock(fd, LOCK_UN);
-	  #endif
-    */
-		fclose(fp);
-	}
-}
diff --git a/indra/llvfs/llvfs.h b/indra/llvfs/llvfs.h
deleted file mode 100644
index 42feafe20b..0000000000
--- a/indra/llvfs/llvfs.h
+++ /dev/null
@@ -1,183 +0,0 @@
-/** 
- * @file llvfs.h
- * @brief Definition of virtual file system
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLVFS_H
-#define LL_LLVFS_H
-
-#include <deque>
-#include "lluuid.h"
-#include "llassettype.h"
-#include "llthread.h"
-#include "llmutex.h"
-
-enum EVFSValid 
-{
-	VFSVALID_UNKNOWN = 0, 
-	VFSVALID_OK = 1,
-	VFSVALID_BAD_CORRUPT = 2,
-	VFSVALID_BAD_CANNOT_OPEN_READONLY = 3,
-	VFSVALID_BAD_CANNOT_CREATE = 4
-};
-
-// Lock types for open vfiles, pending async reads, and pending async appends
-// (There are no async normal writes, currently)
-enum EVFSLock
-{
-	VFSLOCK_OPEN = 0,
-	VFSLOCK_READ = 1,
-	VFSLOCK_APPEND = 2,
-
-	VFSLOCK_COUNT = 3
-};
-
-// internal classes
-class LLVFSBlock;
-class LLVFSFileBlock;
-class LLVFSFileSpecifier
-{
-public:
-	LLVFSFileSpecifier();
-	LLVFSFileSpecifier(const LLUUID &file_id, const LLAssetType::EType file_type);
-	bool operator<(const LLVFSFileSpecifier &rhs) const;
-	bool operator==(const LLVFSFileSpecifier &rhs) const;
-
-public:
-	LLUUID mFileID;
-	LLAssetType::EType mFileType;
-};
-
-class LLVFS
-{
-private:
-	// Use createLLVFS() to open a VFS file
-	// Pass 0 to not presize
-	LLVFS(const std::string& index_filename, 
-			const std::string& data_filename, 
-			const BOOL read_only, 
-			const U32 presize, 
-			const BOOL remove_after_crash);
-public:
-	~LLVFS();
-
-	// Use this function normally to create LLVFS files
-	// Pass 0 to not presize
-	static LLVFS * createLLVFS(const std::string& index_filename, 
-			const std::string& data_filename, 
-			const BOOL read_only, 
-			const U32 presize, 
-			const BOOL remove_after_crash);
-
-	BOOL isValid() const			{ return (VFSVALID_OK == mValid); }
-	EVFSValid getValidState() const	{ return mValid; }
-
-	// ---------- The following fucntions lock/unlock mDataMutex ----------
-	BOOL getExists(const LLUUID &file_id, const LLAssetType::EType file_type);
-	S32	 getSize(const LLUUID &file_id, const LLAssetType::EType file_type);
-
-	BOOL checkAvailable(S32 max_size);
-	
-	S32  getMaxSize(const LLUUID &file_id, const LLAssetType::EType file_type);
-	BOOL setMaxSize(const LLUUID &file_id, const LLAssetType::EType file_type, S32 max_size);
-
-	void renameFile(const LLUUID &file_id, const LLAssetType::EType file_type,
-		const LLUUID &new_id, const LLAssetType::EType &new_type);
-	void removeFile(const LLUUID &file_id, const LLAssetType::EType file_type);
-
-	S32 getData(const LLUUID &file_id, const LLAssetType::EType file_type, U8 *buffer, S32 location, S32 length);
-	S32 storeData(const LLUUID &file_id, const LLAssetType::EType file_type, const U8 *buffer, S32 location, S32 length);
-
-	void incLock(const LLUUID &file_id, const LLAssetType::EType file_type, EVFSLock lock);
-	void decLock(const LLUUID &file_id, const LLAssetType::EType file_type, EVFSLock lock);
-	BOOL isLocked(const LLUUID &file_id, const LLAssetType::EType file_type, EVFSLock lock);
-	// ----------------------------------------------------------------
-
-	// Used to trigger evil WinXP behavior of "preloading" entire file into memory.
-	void pokeFiles();
-
-	// Verify that the index file contents match the in-memory file structure
-	// Very slow, do not call routinely. JC
-	void audit();
-	// Check for uninitialized blocks.  Slow, do not call in release. JC
-	void checkMem();
-	// for debugging, prints a map of the vfs
-	void dumpMap();
-	void dumpLockCounts();
-	void dumpStatistics();
-	void listFiles();
-	void dumpFiles();
-	time_t creationTime();
-
-protected:
-	void removeFileBlock(LLVFSFileBlock *fileblock);
-	
-	void eraseBlockLength(LLVFSBlock *block);
-	void eraseBlock(LLVFSBlock *block);
-	void addFreeBlock(LLVFSBlock *block);
-	//void mergeFreeBlocks();
-	void useFreeSpace(LLVFSBlock *free_block, S32 length);
-	void sync(LLVFSFileBlock *block, BOOL remove = FALSE);
-	void presizeDataFile(const U32 size);
-
-	static LLFILE *openAndLock(const std::string& filename, const char* mode, BOOL read_lock);
-	static void unlockAndClose(FILE *fp);
-	
-	// Can initiate LRU-based file removal to make space.
-	// The immune file block will not be removed.
-	LLVFSBlock *findFreeBlock(S32 size, LLVFSFileBlock *immune = NULL);
-
-	// lock/unlock data mutex (mDataMutex)
-	void lockData() { mDataMutex->lock(); }
-	void unlockData() { mDataMutex->unlock(); }	
-	
-protected:
-	LLMutex* mDataMutex;
-	
-	typedef std::map<LLVFSFileSpecifier, LLVFSFileBlock*> fileblock_map;
-	fileblock_map mFileBlocks;
-
-	typedef std::multimap<S32, LLVFSBlock*>	blocks_length_map_t;
-	blocks_length_map_t 	mFreeBlocksByLength;
-	typedef std::multimap<U32, LLVFSBlock*>	blocks_location_map_t;
-	blocks_location_map_t 	mFreeBlocksByLocation;
-
-	LLFILE *mDataFP;
-	LLFILE *mIndexFP;
-
-	std::deque<S32> mIndexHoles;
-
-	std::string mIndexFilename;
-	std::string mDataFilename;
-	BOOL mReadOnly;
-
-	EVFSValid mValid;
-
-	S32 mLockCounts[VFSLOCK_COUNT];
-	BOOL mRemoveAfterCrash;
-};
-
-extern LLVFS *gVFS;
-
-#endif
diff --git a/indra/llvfs/llvfsthread.cpp b/indra/llvfs/llvfsthread.cpp
deleted file mode 100644
index 8cd85929e2..0000000000
--- a/indra/llvfs/llvfsthread.cpp
+++ /dev/null
@@ -1,300 +0,0 @@
-/** 
- * @file llvfsthread.cpp
- * @brief LLVFSThread implementation
- *
- * $LicenseInfo:firstyear=2001&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-#include "llvfsthread.h"
-#include "llstl.h"
-
-//============================================================================
-
-/*static*/ std::string LLVFSThread::sDataPath = "";
-
-/*static*/ LLVFSThread* LLVFSThread::sLocal = NULL;
-
-//============================================================================
-// Run on MAIN thread
-//static
-void LLVFSThread::initClass(bool local_is_threaded)
-{
-	llassert(sLocal == NULL);
-	sLocal = new LLVFSThread(local_is_threaded);
-}
-
-//static
-S32 LLVFSThread::updateClass(U32 ms_elapsed)
-{
-	sLocal->update((F32)ms_elapsed);
-	return sLocal->getPending();
-}
-
-//static
-void LLVFSThread::cleanupClass()
-{
-	sLocal->setQuitting();
-	while (sLocal->getPending())
-	{
-		sLocal->update(0);
-	}
-	delete sLocal;
-	sLocal = 0;
-}
-
-//----------------------------------------------------------------------------
-
-LLVFSThread::LLVFSThread(bool threaded) :
-	LLQueuedThread("VFS", threaded)
-{
-}
-
-LLVFSThread::~LLVFSThread()
-{
-	// ~LLQueuedThread() will be called here
-}
-
-//----------------------------------------------------------------------------
-
-LLVFSThread::handle_t LLVFSThread::read(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type,
-										U8* buffer, S32 offset, S32 numbytes, U32 priority, U32 flags)
-{
-	handle_t handle = generateHandle();
-
-	priority = llmax(priority, (U32)PRIORITY_LOW); // All reads are at least PRIORITY_LOW
-	Request* req = new Request(handle, priority, flags, FILE_READ, vfs, file_id, file_type,
-							   buffer, offset, numbytes);
-
-	bool res = addRequest(req);
-	if (!res)
-	{
-		LL_ERRS() << "LLVFSThread::read called after LLVFSThread::cleanupClass()" << LL_ENDL;
-		req->deleteRequest();
-		handle = nullHandle();
-	}
-
-	return handle;
-}
-
-S32 LLVFSThread::readImmediate(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type,
-							   U8* buffer, S32 offset, S32 numbytes)
-{
-	handle_t handle = generateHandle();
-
-	Request* req = new Request(handle, PRIORITY_IMMEDIATE, 0, FILE_READ, vfs, file_id, file_type,
-							   buffer, offset, numbytes);
-	
-	S32 res = addRequest(req) ? 1 : 0;
-	if (res == 0)
-	{
-		LL_ERRS() << "LLVFSThread::read called after LLVFSThread::cleanupClass()" << LL_ENDL;
-		req->deleteRequest();
-	}
-	else
-	{
-		llverify(waitForResult(handle, false) == true);
-		res = req->getBytesRead();
-		completeRequest(handle);
-	}
-	return res;
-}
-
-LLVFSThread::handle_t LLVFSThread::write(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type,
-										 U8* buffer, S32 offset, S32 numbytes, U32 flags)
-{
-	handle_t handle = generateHandle();
-
-	Request* req = new Request(handle, 0, flags, FILE_WRITE, vfs, file_id, file_type,
-							   buffer, offset, numbytes);
-
-	bool res = addRequest(req);
-	if (!res)
-	{
-		LL_ERRS() << "LLVFSThread::read called after LLVFSThread::cleanupClass()" << LL_ENDL;
-		req->deleteRequest();
-		handle = nullHandle();
-	}
-	
-	return handle;
-}
-
-S32 LLVFSThread::writeImmediate(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type,
-								 U8* buffer, S32 offset, S32 numbytes)
-{
-	handle_t handle = generateHandle();
-
-	Request* req = new Request(handle, PRIORITY_IMMEDIATE, 0, FILE_WRITE, vfs, file_id, file_type,
-							   buffer, offset, numbytes);
-
-	S32 res = addRequest(req) ? 1 : 0;
-	if (res == 0)
-	{
-		LL_ERRS() << "LLVFSThread::read called after LLVFSThread::cleanupClass()" << LL_ENDL;
-		req->deleteRequest();
-	}
-	else
-	{
-		llverify(waitForResult(handle, false) == true);
-		res = req->getBytesRead();
-		completeRequest(handle);
-	}
-	return res;
-}
-
-
-// LLVFSThread::handle_t LLVFSThread::rename(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type,
-// 										  const LLUUID &new_id, const LLAssetType::EType new_type, U32 flags)
-// {
-// 	handle_t handle = generateHandle();
-
-// 	LLUUID* new_idp = new LLUUID(new_id); // deleted with Request
-// 	// new_type is passed as "numbytes"
-// 	Request* req = new Request(handle, 0, flags, FILE_RENAME, vfs, file_id, file_type,
-// 							   (U8*)new_idp, 0, (S32)new_type);
-
-// 	bool res = addRequest(req);
-// 	if (!res)
-// 	{
-// 		LL_ERRS() << "LLVFSThread::read called after LLVFSThread::cleanupClass()" << LL_ENDL;
-// 		req->deleteRequest();
-// 		handle = nullHandle();
-// 	}
-	
-// 	return handle;
-// }
-
-//============================================================================
-
-LLVFSThread::Request::Request(handle_t handle, U32 priority, U32 flags,
-							  operation_t op, LLVFS* vfs,
-							  const LLUUID &file_id, const LLAssetType::EType file_type,
-							  U8* buffer, S32 offset, S32 numbytes) :
-	QueuedRequest(handle, priority, flags),
-	mOperation(op),
-	mVFS(vfs),
-	mFileID(file_id),
-	mFileType(file_type),
-	mBuffer(buffer),
-	mOffset(offset),
-	mBytes(numbytes),
-	mBytesRead(0)
-{
-	llassert(mBuffer);
-
-	if (numbytes <= 0 && mOperation != FILE_RENAME)
-	{
-		LL_WARNS() << "LLVFSThread: Request with numbytes = " << numbytes 
-			<< " operation = " << op
-			<< " offset " << offset 
-			<< " file_type " << file_type << LL_ENDL;
-	}
-	if (mOperation == FILE_WRITE)
-	{
-		S32 blocksize =  mVFS->getMaxSize(mFileID, mFileType);
-		if (blocksize < 0)
-		{
-			LL_WARNS() << "VFS write to temporary block (shouldn't happen)" << LL_ENDL;
-		}
-		mVFS->incLock(mFileID, mFileType, VFSLOCK_APPEND);
-	}
-	else if (mOperation == FILE_RENAME)
-	{
-		mVFS->incLock(mFileID, mFileType, VFSLOCK_APPEND);
-	}
-	else // if (mOperation == FILE_READ)
-	{
-		mVFS->incLock(mFileID, mFileType, VFSLOCK_READ);
-	}
-}
-
-// dec locks as soon as a request finishes
-void LLVFSThread::Request::finishRequest(bool completed)
-{
-	if (mOperation == FILE_WRITE)
-	{
-		mVFS->decLock(mFileID, mFileType, VFSLOCK_APPEND);
-	}
-	else if (mOperation == FILE_RENAME)
-	{
-		mVFS->decLock(mFileID, mFileType, VFSLOCK_APPEND);
-	}
-	else // if (mOperation == FILE_READ)
-	{
-		mVFS->decLock(mFileID, mFileType, VFSLOCK_READ);
-	}
-}
-
-void LLVFSThread::Request::deleteRequest()
-{
-	if (getStatus() == STATUS_QUEUED)
-	{
-		LL_ERRS() << "Attempt to delete a queued LLVFSThread::Request!" << LL_ENDL;
-	}	
-	if (mOperation == FILE_WRITE)
-	{
-		if (mFlags & FLAG_AUTO_DELETE)
-		{
-			delete [] mBuffer;
-		}
-	}
-	else if (mOperation == FILE_RENAME)
-	{
-		LLUUID* new_idp = (LLUUID*)mBuffer;
-		delete new_idp;
-	}
-	LLQueuedThread::QueuedRequest::deleteRequest();
-}
-
-bool LLVFSThread::Request::processRequest()
-{
-	bool complete = false;
-	if (mOperation ==  FILE_READ)
-	{
-		llassert(mOffset >= 0);
-		mBytesRead = mVFS->getData(mFileID, mFileType, mBuffer, mOffset, mBytes);
-		complete = true;
-		//LL_INFOS() << llformat("LLVFSThread::READ '%s': %d bytes arg:%d",getFilename(),mBytesRead) << LL_ENDL;
-	}
-	else if (mOperation ==  FILE_WRITE)
-	{
-		mBytesRead = mVFS->storeData(mFileID, mFileType, mBuffer, mOffset, mBytes);
-		complete = true;
-		//LL_INFOS() << llformat("LLVFSThread::WRITE '%s': %d bytes arg:%d",getFilename(),mBytesRead) << LL_ENDL;
-	}
-	else if (mOperation ==  FILE_RENAME)
-	{
-		LLUUID* new_idp = (LLUUID*)mBuffer;
-		LLAssetType::EType new_type = (LLAssetType::EType)mBytes;
-		mVFS->renameFile(mFileID, mFileType, *new_idp, new_type);
-		mFileID = *new_idp;
-		complete = true;
-		//LL_INFOS() << llformat("LLVFSThread::RENAME '%s': %d bytes arg:%d",getFilename(),mBytesRead) << LL_ENDL;
-	}
-	else
-	{
-		LL_ERRS() << llformat("LLVFSThread::unknown operation: %d", mOperation) << LL_ENDL;
-	}
-	return complete;
-}
-
-//============================================================================
diff --git a/indra/llvfs/llvfsthread.h b/indra/llvfs/llvfsthread.h
deleted file mode 100644
index 7814de4a2d..0000000000
--- a/indra/llvfs/llvfsthread.h
+++ /dev/null
@@ -1,140 +0,0 @@
-/** 
- * @file llvfsthread.h
- * @brief LLVFSThread definition
- *
- * $LicenseInfo:firstyear=2001&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLVFSTHREAD_H
-#define LL_LLVFSTHREAD_H
-
-#include <queue>
-#include <string>
-#include <map>
-#include <set>
-
-#include "llqueuedthread.h"
-
-#include "llvfs.h"
-
-//============================================================================
-
-class LLVFSThread : public LLQueuedThread
-{
-	//------------------------------------------------------------------------
-public:
-	enum operation_t {
-		FILE_READ,
-		FILE_WRITE,
-		FILE_RENAME
-	};
-
-	//------------------------------------------------------------------------
-public:
-
-	class Request : public QueuedRequest
-	{
-	protected:
-		~Request() {}; // use deleteRequest()
-		
-	public:
-		Request(handle_t handle, U32 priority, U32 flags,
-				operation_t op, LLVFS* vfs,
-				const LLUUID &file_id, const LLAssetType::EType file_type,
-				U8* buffer, S32 offset, S32 numbytes);
-
-		S32 getBytesRead()
-		{
-			return mBytesRead;
-		}
-		S32 getOperation()
-		{
-			return mOperation;
-		}
-		U8* getBuffer()
-		{
-			return mBuffer;
-		}
-		LLVFS* getVFS()
-		{
-			return mVFS;
-		}
-		std::string getFilename()
-		{
-			std::string tstring;
-			mFileID.toString(tstring);
-			return tstring;
-		}
-		
-		/*virtual*/ bool processRequest();
-		/*virtual*/ void finishRequest(bool completed);
-		/*virtual*/ void deleteRequest();
-		
-	private:
-		operation_t mOperation;
-		
-		LLVFS* mVFS;
-		LLUUID mFileID;
-		LLAssetType::EType mFileType;
-		
-		U8* mBuffer;	// dest for reads, source for writes, new UUID for rename
-		S32 mOffset;	// offset into file, -1 = append (WRITE only)
-		S32 mBytes;		// bytes to read from file, -1 = all (new mFileType for rename)
-		S32	mBytesRead;	// bytes read from file
-	};
-
-	//------------------------------------------------------------------------
-public:
-	static std::string sDataPath;
-	static LLVFSThread* sLocal;		// Default worker thread
-	
-public:
-	LLVFSThread(bool threaded = TRUE);
-	~LLVFSThread();	
-
-	// Return a Request handle
-	handle_t read(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type,	/* Flawfinder: ignore */
-				  U8* buffer, S32 offset, S32 numbytes, U32 pri=PRIORITY_NORMAL, U32 flags = 0);
-	handle_t write(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type,
-				   U8* buffer, S32 offset, S32 numbytes, U32 flags);
-	// SJB: rename seems to have issues, especially when threaded
-// 	handle_t rename(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type,
-// 					const LLUUID &new_id, const LLAssetType::EType new_type, U32 flags);
-	// Return number of bytes read
-	S32 readImmediate(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type,
-					  U8* buffer, S32 offset, S32 numbytes);
-	S32 writeImmediate(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type,
-					   U8* buffer, S32 offset, S32 numbytes);
-
-	/*virtual*/ bool processRequest(QueuedRequest* req);
-
-public:
-	static void initClass(bool local_is_threaded = TRUE); // Setup sLocal
-	static S32 updateClass(U32 ms_elapsed);
-	static void cleanupClass();		// Delete sLocal
-	static void setDataPath(const std::string& path) { sDataPath = path; }
-};
-
-//============================================================================
-
-
-#endif // LL_LLVFSTHREAD_H
diff --git a/indra/llwindow/CMakeLists.txt b/indra/llwindow/CMakeLists.txt
index 8bfb23ed64..70eb99c86c 100644
--- a/indra/llwindow/CMakeLists.txt
+++ b/indra/llwindow/CMakeLists.txt
@@ -16,7 +16,7 @@ include(LLCommon)
 include(LLImage)
 include(LLMath)
 include(LLRender)
-include(LLVFS)
+include(LLFileSystem)
 include(LLWindow)
 include(LLXML)
 include(UI)
@@ -26,7 +26,7 @@ include_directories(
     ${LLIMAGE_INCLUDE_DIRS}
     ${LLMATH_INCLUDE_DIRS}
     ${LLRENDER_INCLUDE_DIRS}
-    ${LLVFS_INCLUDE_DIRS}
+    ${LLFILESYSTEM_INCLUDE_DIRS}
     ${LLWINDOW_INCLUDE_DIRS}
     ${LLXML_INCLUDE_DIRS}
     )
@@ -72,7 +72,7 @@ if (LINUX)
       ${LLIMAGE_LIBRARIES}
       ${LLMATH_LIBRARIES}
       ${LLRENDER_LIBRARIES}
-      ${LLVFS_LIBRARIES}
+      ${LLFILESYSTEM_LIBRARIES}
       ${LLWINDOW_LIBRARIES}
       ${LLXML_LIBRARIES}
       ${UI_LIBRARIES}     # for GTK
@@ -95,7 +95,7 @@ if (LINUX)
         ${LLIMAGE_LIBRARIES}
         ${LLMATH_LIBRARIES}
         ${LLRENDER_HEADLESS_LIBRARIES}
-        ${LLVFS_LIBRARIES}
+        ${LLFILESYSTEM_LIBRARIES}
         ${LLWINDOW_HEADLESS_LIBRARIES}
         ${LLXML_LIBRARIES}
         fontconfig          # For FCInit and other FC* functions.
diff --git a/indra/llxml/CMakeLists.txt b/indra/llxml/CMakeLists.txt
index 013a422d35..3a7a54e51d 100644
--- a/indra/llxml/CMakeLists.txt
+++ b/indra/llxml/CMakeLists.txt
@@ -5,13 +5,13 @@ project(llxml)
 include(00-Common)
 include(LLCommon)
 include(LLMath)
-include(LLVFS)
+include(LLFileSystem)
 include(LLXML)
 
 include_directories(
     ${LLCOMMON_INCLUDE_DIRS}
     ${LLMATH_INCLUDE_DIRS}
-    ${LLVFS_INCLUDE_DIRS}
+    ${LLFILESYSTEM_INCLUDE_DIRS}
     )
 include_directories(
     ${LLCOMMON_SYSTEM_INCLUDE_DIRS}
@@ -42,7 +42,7 @@ add_library (llxml ${llxml_SOURCE_FILES})
 # Libraries on which this library depends, needed for Linux builds
 # Sort by high-level to low-level
 target_link_libraries( llxml
-    ${LLVFS_LIBRARIES}
+    ${LLFILESYSTEM_LIBRARIES}
     ${LLMATH_LIBRARIES}
     ${LLCOMMON_LIBRARIES}
     ${EXPAT_LIBRARIES}
diff --git a/indra/media_plugins/cef/media_plugin_cef.cpp b/indra/media_plugins/cef/media_plugin_cef.cpp
index c413263619..d28caab490 100644
--- a/indra/media_plugins/cef/media_plugin_cef.cpp
+++ b/indra/media_plugins/cef/media_plugin_cef.cpp
@@ -62,7 +62,7 @@ private:
 	void onTooltipCallback(std::string text);
 	void onLoadStartCallback();
 	void onRequestExitCallback();
-	void onLoadEndCallback(int httpStatusCode);
+	void onLoadEndCallback(int httpStatusCode, std::string url);
 	void onLoadError(int status, const std::string error_text);
 	void onAddressChangeCallback(std::string url);
 	void onOpenPopupCallback(std::string url, std::string target);
@@ -89,6 +89,8 @@ private:
 	bool mDisableGPU;
 	bool mDisableNetworkService;
 	bool mUseMockKeyChain;
+	bool mDisableWebSecurity;
+	bool mFileAccessFromFileUrls;
 	std::string mUserAgentSubtring;
 	std::string mAuthUsername;
 	std::string mAuthPassword;
@@ -124,6 +126,8 @@ MediaPluginBase(host_send_func, host_user_data)
 	mDisableGPU = false;
 	mDisableNetworkService = true;
 	mUseMockKeyChain = true;
+	mDisableWebSecurity = false;
+	mFileAccessFromFileUrls = false;
 	mUserAgentSubtring = "";
 	mAuthUsername = "";
 	mAuthPassword = "";
@@ -257,13 +261,14 @@ void MediaPluginCEF::onRequestExitCallback()
 
 ////////////////////////////////////////////////////////////////////////////////
 //
-void MediaPluginCEF::onLoadEndCallback(int httpStatusCode)
+void MediaPluginCEF::onLoadEndCallback(int httpStatusCode, std::string url)
 {
 	LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "navigate_complete");
 	//message.setValue("uri", event.getEventUri());  // not easily available here in CEF - needed?
 	message.setValueS32("result_code", httpStatusCode);
 	message.setValueBoolean("history_back_available", mCEFLib->canGoBack());
 	message.setValueBoolean("history_forward_available", mCEFLib->canGoForward());
+	message.setValue("uri", url);
 	sendMessage(message);
 }
 
@@ -352,14 +357,16 @@ const std::vector<std::string> MediaPluginCEF::onFileDialog(dullahan::EFileDialo
 	}
 	else if (dialog_type == dullahan::FD_SAVE_FILE)
 	{
+		mPickedFiles.clear();
 		mAuthOK = false;
 
 		LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "file_download");
+		message.setValueBoolean("blocking_request", true);
 		message.setValue("filename", default_file);
 
 		sendMessage(message);
 
-		return std::vector<std::string>();
+		return mPickedFiles;
 	}
 
 	return std::vector<std::string>();
@@ -585,7 +592,7 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 				mCEFLib->setOnTitleChangeCallback(std::bind(&MediaPluginCEF::onTitleChangeCallback, this, std::placeholders::_1));
 				mCEFLib->setOnTooltipCallback(std::bind(&MediaPluginCEF::onTooltipCallback, this, std::placeholders::_1));
 				mCEFLib->setOnLoadStartCallback(std::bind(&MediaPluginCEF::onLoadStartCallback, this));
-				mCEFLib->setOnLoadEndCallback(std::bind(&MediaPluginCEF::onLoadEndCallback, this, std::placeholders::_1));
+				mCEFLib->setOnLoadEndCallback(std::bind(&MediaPluginCEF::onLoadEndCallback, this, std::placeholders::_1, std::placeholders::_2));
 				mCEFLib->setOnLoadErrorCallback(std::bind(&MediaPluginCEF::onLoadError, this, std::placeholders::_1, std::placeholders::_2));
 				mCEFLib->setOnAddressChangeCallback(std::bind(&MediaPluginCEF::onAddressChangeCallback, this, std::placeholders::_1));
 				mCEFLib->setOnOpenPopupCallback(std::bind(&MediaPluginCEF::onOpenPopupCallback, this, std::placeholders::_1, std::placeholders::_2));
@@ -624,6 +631,19 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 				settings.disable_network_service = mDisableNetworkService;
 				settings.use_mock_keychain = mUseMockKeyChain;
 #endif
+                // these were added to facilitate loading images directly into a local
+                // web page for the prototype 360 project in 2017 - something that is 
+                // disallowed normally by the browser security model. Now the the source
+                // (cubemap) images are stores as JavaScript, we can avoid opening up
+                // this security hole (it was only set for the 360 floater but still 
+                // a concern). Leaving them here, explicitly turn off vs removing 
+                // entirely from this source file so that others are aware of them 
+                // in the future.
+                settings.disable_web_security = false;
+                settings.file_access_from_file_urls = false;
+
+                settings.flash_enabled = mPluginsEnabled;
+
 				// This setting applies to all plugins, not just Flash
 				// Regarding, SL-15559 PDF files do not load in CEF v91,
 				// it turns out that on Windows, PDF support is treated
@@ -750,6 +770,11 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 				std::string uri = message_in.getValue("uri");
 				mCEFLib->navigate(uri);
 			}
+			else if (message_name == "execute_javascript")
+			{
+				std::string code = message_in.getValue("code");
+				mCEFLib->executeJavaScript(code);
+			}
 			else if (message_name == "set_cookie")
 			{
 				std::string uri = message_in.getValue("uri");
@@ -945,6 +970,14 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 			{
 				mDisableGPU = message_in.getValueBoolean("disable");
 			}
+			else if (message_name == "web_security_disabled")
+			{
+				mDisableWebSecurity = message_in.getValueBoolean("disabled");
+			}
+			else if (message_name == "file_access_from_file_urls")
+			{
+				mFileAccessFromFileUrls = message_in.getValueBoolean("enabled");
+			}
 		}
         else if (message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME)
         {
diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt
index 1969c498f0..5a06106de3 100644
--- a/indra/newview/CMakeLists.txt
+++ b/indra/newview/CMakeLists.txt
@@ -12,12 +12,14 @@ include(bugsplat)
 include(BuildPackagesInfo)
 include(BuildVersion)
 include(CMakeCopyIfDifferent)
+include(CubemapToEquirectangularJS)
 include(DBusGlib)
 include(DragDrop)
 include(EXPAT)
 include(FMODSTUDIO)
 include(GLOD)
 include(Hunspell)
+include(JPEGEncoderBasic)
 include(JsonCpp)
 include(LLAppearance)
 include(LLAudio)
@@ -37,7 +39,7 @@ include(LLPlugin)
 include(LLPrimitive)
 include(LLRender)
 include(LLUI)
-include(LLVFS)
+include(LLFileSystem)
 include(LLWindow)
 include(LLXML)
 include(NDOF)
@@ -47,6 +49,7 @@ include(OpenGL)
 include(OpenSSL)
 include(PNG)
 include(TemplateCheck)
+include(ThreeJS)
 include(UI)
 include(UnixInstall)
 include(ViewerMiscLibs)
@@ -82,7 +85,7 @@ include_directories(
     ${LLPRIMITIVE_INCLUDE_DIRS}
     ${LLRENDER_INCLUDE_DIRS}
     ${LLUI_INCLUDE_DIRS}
-    ${LLVFS_INCLUDE_DIRS}
+    ${LLFILESYSTEM_INCLUDE_DIRS}
     ${LLWINDOW_INCLUDE_DIRS}
     ${LLXML_INCLUDE_DIRS}
     ${LLLOGIN_INCLUDE_DIRS}
@@ -205,6 +208,7 @@ set(viewer_SOURCE_FILES
     llfilteredwearablelist.cpp
     llfirstuse.cpp
     llflexibleobject.cpp
+    llfloater360capture.cpp
     llfloaterabout.cpp
     llfloaterbvhpreview.cpp
     llfloateraddpaymentmethod.cpp
@@ -278,7 +282,7 @@ set(viewer_SOURCE_FILES
     llfloaternamedesc.cpp
     llfloaternotificationsconsole.cpp
     llfloaternotificationstabbed.cpp
-    llfloateroutfitphotopreview.cpp 
+    llfloateroutfitphotopreview.cpp
     llfloateroutfitsnapshot.cpp
     llfloaterobjectweights.cpp
     llfloateropenobject.cpp
@@ -844,6 +848,7 @@ set(viewer_HEADER_FILES
     llfilteredwearablelist.h
     llfirstuse.h
     llflexibleobject.h
+    llfloater360capture.h
     llfloaterabout.h
     llfloaterbvhpreview.h
     llfloateraddpaymentmethod.h
@@ -1381,7 +1386,7 @@ file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/viewer_version.txt"
            "${VIEWER_SHORT_VERSION}.${VIEWER_VERSION_REVISION}\n")
 
 set_source_files_properties(
-   llversioninfo.cpp tests/llversioninfo_test.cpp 
+   llversioninfo.cpp tests/llversioninfo_test.cpp
    PROPERTIES
    COMPILE_DEFINITIONS "${VIEWER_CHANNEL_VERSION_DEFINES}" # see BuildVersion.cmake
    )
@@ -2002,7 +2007,7 @@ endif (WINDOWS)
 # one of these being libz where you can find four or more versions in play
 # at once.  On Linux, libz can be found at link and run time via a number
 # of paths:
-#     
+#
 #      => -lfreetype
 #        => libz.so.1 (on install machine, not build)
 #      => -lSDL
@@ -2033,7 +2038,7 @@ target_link_libraries(${VIEWER_BINARY_NAME}
     ${LLRENDER_LIBRARIES}
     ${FREETYPE_LIBRARIES}
     ${LLUI_LIBRARIES}
-    ${LLVFS_LIBRARIES}
+    ${LLFILESYSTEM_LIBRARIES}
     ${LLWINDOW_LIBRARIES}
     ${LLXML_LIBRARIES}
     ${LLMATH_LIBRARIES}
@@ -2173,7 +2178,7 @@ if (DARWIN)
 
   # https://blog.kitware.com/upcoming-in-cmake-2-8-12-osx-rpath-support/
   set(CMAKE_MACOSX_RPATH 1)
-  
+
   set_target_properties(
     ${VIEWER_BINARY_NAME}
     PROPERTIES
@@ -2375,7 +2380,7 @@ if (LL_TESTS)
     llworldmap.cpp
     llworldmipmap.cpp
     PROPERTIES
-    LL_TEST_ADDITIONAL_SOURCE_FILES 
+    LL_TEST_ADDITIONAL_SOURCE_FILES
     tests/llviewertexture_stub.cpp
     #llviewertexturelist.cpp
   )
@@ -2409,7 +2414,7 @@ if (LL_TESTS)
     llworldmap.cpp
     llworldmipmap.cpp
     PROPERTIES
-    LL_TEST_ADDITIONAL_SOURCE_FILES 
+    LL_TEST_ADDITIONAL_SOURCE_FILES
     tests/llviewertexture_stub.cpp
     #llviewertexturelist.cpp
     LL_TEST_ADDITIONAL_LIBRARIES "${BOOST_SYSTEM_LIBRARY}"
@@ -2456,7 +2461,7 @@ if (LL_TESTS)
   set(test_libs
     ${LLMESSAGE_LIBRARIES}
     ${WINDOWS_LIBRARIES}
-    ${LLVFS_LIBRARIES}
+    ${LLFILESYSTEM_LIBRARIES}
     ${LLMATH_LIBRARIES}
     ${LLCOMMON_LIBRARIES}
     ${GOOGLEMOCK_LIBRARIES}
@@ -2471,7 +2476,7 @@ if (LL_TESTS)
 
   set(test_libs
     ${WINDOWS_LIBRARIES}
-    ${LLVFS_LIBRARIES}
+    ${LLFILESYSTEM_LIBRARIES}
     ${LLMATH_LIBRARIES}
     ${LLCOMMON_LIBRARIES}
     ${LLMESSAGE_LIBRARIES}
diff --git a/indra/newview/VIEWER_VERSION.txt b/indra/newview/VIEWER_VERSION.txt
index a194c18e86..5e3ec53ea6 100644
--- a/indra/newview/VIEWER_VERSION.txt
+++ b/indra/newview/VIEWER_VERSION.txt
@@ -1 +1 @@
-6.5.1
+6.5.2
diff --git a/indra/newview/app_settings/commands.xml b/indra/newview/app_settings/commands.xml
index d0480ca47e..3dfe3f6634 100644
--- a/indra/newview/app_settings/commands.xml
+++ b/indra/newview/app_settings/commands.xml
@@ -276,4 +276,15 @@
          is_running_function="Floater.IsOpen"
          is_running_parameters="my_environments"
            />
+  <command name="360capture"
+         available_in_toybox="true"
+         is_flashing_allowed="true"
+         icon="Command_360_Capture_Icon"
+         label_ref="Command_360_Capture_Label"
+         tooltip_ref="Command_360_Capture_Tooltip"
+         execute_function="Floater.ToggleOrBringToFront"
+         execute_parameters="360capture"
+         is_running_function="Floater.IsOpen"
+         is_running_parameters="360capture"
+           />
 </commands>
diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml
index 6d93ba927f..57ea585d0a 100644
--- a/indra/newview/app_settings/settings.xml
+++ b/indra/newview/app_settings/settings.xml
@@ -1362,6 +1362,39 @@
       <key>Value</key>
       <integer>23</integer>
     </map>
+    <key>EnableDiskCacheDebugInfo</key>
+    <map>
+      <key>Comment</key>
+      <string>When set, display additional cache debugging information</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>0</integer>
+    </map>
+    <key>DiskCachePercentOfTotal</key>
+    <map>
+      <key>Comment</key>
+      <string>The percent of total cache size (defined by CacheSize) to use for the disk cache</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>F32</string>
+      <key>Value</key>
+      <real>20.0</real>
+    </map>
+    <key>DiskCacheDirName</key>
+    <map>
+      <key>Comment</key>
+      <string>The name of the disk cache (within the standard Viewer disk cache directory)</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>String</string>
+      <key>Value</key>
+      <string>cache</string>
+    </map>
     <key>CacheLocation</key>
     <map>
       <key>Comment</key>
@@ -2077,6 +2110,28 @@
       <key>Value</key>
       <integer>1</integer>
     </map>
+    <key>BrowserFileAccessFromFileUrls</key>
+    <map>
+      <key>Comment</key>
+      <string>Allow access to local files via file urls in the embedded browser</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>1</integer>
+    </map>
+    <key>BrowserPluginsEnabled</key>
+    <map>
+      <key>Comment</key>
+      <string>Enable Web plugins in the built-in Web browser?</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>1</integer>
+    </map>
     <key>ChatBarCustomWidth</key>
     <map>
       <key>Comment</key>
@@ -2826,17 +2881,6 @@
       <key>Value</key>
       <integer>-1</integer>
     </map>
-    <key>DebugStatModeVFSPendingOps</key>
-    <map>
-      <key>Comment</key>
-      <string>Mode of stat in Statistics floater</string>
-      <key>Persist</key>
-      <integer>1</integer>
-      <key>Type</key>
-      <string>S32</string>
-      <key>Value</key>
-      <integer>-1</integer>
-    </map>
     <key>DebugStatModeTimeDialation</key>
     <map>
       <key>Comment</key>
@@ -3541,7 +3585,7 @@
       <key>Value</key>
       <integer>0</integer>
     </map>
-    <key>DoubleClickTeleport</key> 
+    <key>DoubleClickTeleport</key>
     <map>
       <key>Comment</key>
       <string>Enable double-click to teleport where allowed (afects minimap and people panel)</string>
@@ -3629,17 +3673,6 @@
       <key>Value</key>
       <integer>4</integer>
     </map>
-    <key>DumpVFSCaches</key>
-    <map>
-      <key>Comment</key>
-      <string>Dump VFS caches on startup.</string>
-      <key>Persist</key>
-      <integer>1</integer>
-      <key>Type</key>
-      <string>Boolean</string>
-      <key>Value</key>
-      <integer>0</integer>
-    </map>
     <key>DynamicCameraStrength</key>
     <map>
       <key>Comment</key>
@@ -8873,7 +8906,7 @@
     <key>Value</key>
     <integer>0</integer>
   </map>
-   <key>RenderHiDPI</key>
+    <key>RenderHiDPI</key>
   <map>
     <key>Comment</key>
     <string>Enable support for HiDPI displays, like Retina (MacOS X ONLY, requires restart)</string>
@@ -11595,7 +11628,7 @@
             <string>Boolean</string>
         <key>Value</key>
             <integer>0</integer>
-    </map> 
+    </map>
     <key>NearbyListShowMap</key>
     <map>
       <key>Comment</key>
@@ -14307,28 +14340,6 @@
       <key>Value</key>
       <string/>
     </map>
-    <key>VFSOldSize</key>
-    <map>
-      <key>Comment</key>
-      <string>[DO NOT MODIFY] Controls resizing of local file cache</string>
-      <key>Persist</key>
-      <integer>1</integer>
-      <key>Type</key>
-      <string>U32</string>
-      <key>Value</key>
-      <integer>0</integer>
-    </map>
-    <key>VFSSalt</key>
-    <map>
-      <key>Comment</key>
-      <string>[DO NOT MODIFY] Controls local file caching behavior</string>
-      <key>Persist</key>
-      <integer>1</integer>
-      <key>Type</key>
-      <string>U32</string>
-      <key>Value</key>
-      <integer>1</integer>
-    </map>
     <key>VelocityInterpolate</key>
     <map>
       <key>Comment</key>
@@ -16703,9 +16714,95 @@
       <key>Type</key>
       <string>Boolean</string>
       <key>Value</key>
-      <integer>1</integer>        
+      <integer>1</integer>
+  </map>
+  <key>360CaptureUseInterestListCap</key>
+  <map>
+    <key>Comment</key>
+    <string>Flag if set, uses the new InterestList cap to ask the simulator for full content</string>
+    <key>Persist</key>
+    <integer>1</integer>
+    <key>Type</key>
+    <string>Boolean</string>
+    <key>Value</key>
+    <integer>1</integer>
+  </map>
+  <key>360CaptureJPEGEncodeQuality</key>
+  <map>
+    <key>Comment</key>
+    <string>Quality value to use in the JPEG encoder (0..100)</string>
+    <key>Persist</key>
+    <integer>1</integer>
+    <key>Type</key>
+    <string>U32</string>
+    <key>Value</key>
+    <integer>95</integer>
+  </map>
+  <key>360CaptureDebugSaveImage</key>
+  <map>
+    <key>Comment</key>
+    <string>Flag if set, saves off each cube map as an image, as well as the JavaScript data URL, for debugging purposes</string>
+    <key>Persist</key>
+    <integer>1</integer>
+    <key>Type</key>
+    <string>Boolean</string>
+    <key>Value</key>
+    <integer>0</integer>
+  </map>
+  <key>360CaptureOutputImageWidth</key>
+  <map>
+    <key>Comment</key>
+    <string>Width of the output 360 equirectangular image</string>
+    <key>Persist</key>
+    <integer>1</integer>
+    <key>Type</key>
+    <string>U32</string>
+    <key>Value</key>
+    <integer>4096</integer>
+  </map>
+  <key>360CaptureHideAvatars</key>
+  <map>
+    <key>Comment</key>
+    <string>Flag if set, removes all the avatars from the 360 snapshot</string>
+    <key>Persist</key>
+    <integer>1</integer>
+    <key>Type</key>
+    <string>Boolean</string>
+    <key>Value</key>
+    <integer>0</integer>
     </map>
+  <key>360CaptureCameraFOV</key>
+  <map>
+    <key>Comment</key>
+    <string>Field of view of the WebGL camera that converts the cubemap to an equirectangular image</string>
+    <key>Persist</key>
+    <integer>1</integer>
+    <key>Type</key>
+    <string>U32</string>
+    <key>Value</key>
+    <integer>75</integer>
+  </map>
+  <key>360CaptureNumRenderPasses</key>
+  <map>
+    <key>Comment</key>
+    <string>Number of times to render the scene while taking a snapshot</string>
+    <key>Persist</key>
+    <integer>1</integer>
+    <key>Type</key>
+    <string>U32</string>
+    <key>Value</key>
+    <integer>3</integer>
+  </map>
+  <key>ResetUIScaleOnFirstRun</key>
+  <map>
+  <key>Comment</key>
+  <string>Resets the UI scale factor on first run due to changed display scaling behavior</string>
+  <key>Persist</key>
+  <integer>1</integer>
+  <key>Type</key>
+  <string>Boolean</string>
+  <key>Value</key>
+  <integer>1</integer>
+  </map>
 </map>
 </llsd>
-
-
diff --git a/indra/newview/app_settings/static_data.db2 b/indra/newview/app_settings/static_data.db2
deleted file mode 100644
index f85aa81601..0000000000
--- a/indra/newview/app_settings/static_data.db2
+++ /dev/null
diff --git a/indra/newview/app_settings/static_index.db2 b/indra/newview/app_settings/static_index.db2
deleted file mode 100644
index a5440f96f2..0000000000
--- a/indra/newview/app_settings/static_index.db2
+++ /dev/null
diff --git a/indra/newview/llagent.cpp b/indra/newview/llagent.cpp
index 91082e053b..9cae1dd930 100644
--- a/indra/newview/llagent.cpp
+++ b/indra/newview/llagent.cpp
@@ -2895,7 +2895,7 @@ bool LLAgent::requestGetCapability(const std::string &capName, httpCallback_t cb
 {
     std::string url;
 
-    url = getRegion()->getCapability(capName);
+    url = getRegionCapability(capName);
 
     if (url.empty())
     {
@@ -4626,23 +4626,19 @@ void LLAgent::requestAgentUserInfoCoro(std::string capurl)
         return;
     }
 
-    bool im_via_email;
-    bool is_verified_email;
     std::string email;
     std::string dir_visibility;
 
-    im_via_email = result["im_via_email"].asBoolean();
-    is_verified_email = result["is_verified"].asBoolean();
     email = result["email"].asString();
     dir_visibility = result["directory_visibility"].asString();
 
     // TODO: This should probably be changed.  I'm not entirely comfortable 
     // having LLAgent interact directly with the UI in this way.
-    LLFloaterPreference::updateUserInfo(dir_visibility, im_via_email, is_verified_email);
+    LLFloaterPreference::updateUserInfo(dir_visibility);
     LLFloaterSnapshot::setAgentEmail(email);
 }
 
-void LLAgent::sendAgentUpdateUserInfo(bool im_via_email, const std::string& directory_visibility)
+void LLAgent::sendAgentUpdateUserInfo(const std::string& directory_visibility)
 {
     std::string cap;
 
@@ -4655,16 +4651,16 @@ void LLAgent::sendAgentUpdateUserInfo(bool im_via_email, const std::string& dire
     if (!cap.empty())
     {
         LLCoros::instance().launch("updateAgentUserInfoCoro",
-            boost::bind(&LLAgent::updateAgentUserInfoCoro, this, cap, im_via_email, directory_visibility));
+            boost::bind(&LLAgent::updateAgentUserInfoCoro, this, cap, directory_visibility));
     }
     else
     {
-        sendAgentUpdateUserInfoMessage(im_via_email, directory_visibility);
+        sendAgentUpdateUserInfoMessage(directory_visibility);
     }
 }
 
 
-void LLAgent::updateAgentUserInfoCoro(std::string capurl, bool im_via_email, std::string directory_visibility)
+void LLAgent::updateAgentUserInfoCoro(std::string capurl, std::string directory_visibility)
 {
     LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
@@ -4675,8 +4671,8 @@ void LLAgent::updateAgentUserInfoCoro(std::string capurl, bool im_via_email, std
 
     httpOpts->setFollowRedirects(true);
     LLSD body(LLSDMap
-        ("dir_visibility",  LLSD::String(directory_visibility))
-        ("im_via_email",    LLSD::Boolean(im_via_email)));
+        ("dir_visibility",  LLSD::String(directory_visibility)));
+
 
     LLSD result = httpAdapter->postAndSuspend(httpRequest, capurl, body, httpOpts, httpHeaders);
 
@@ -4704,14 +4700,13 @@ void LLAgent::sendAgentUserInfoRequestMessage()
     sendReliableMessage();
 }
 
-void LLAgent::sendAgentUpdateUserInfoMessage(bool im_via_email, const std::string& directory_visibility)
+void LLAgent::sendAgentUpdateUserInfoMessage(const std::string& directory_visibility)
 {
     gMessageSystem->newMessageFast(_PREHASH_UpdateUserInfo);
     gMessageSystem->nextBlockFast(_PREHASH_AgentData);
     gMessageSystem->addUUIDFast(_PREHASH_AgentID, getID());
     gMessageSystem->addUUIDFast(_PREHASH_SessionID, getSessionID());
     gMessageSystem->nextBlockFast(_PREHASH_UserData);
-    gMessageSystem->addBOOLFast(_PREHASH_IMViaEMail, im_via_email);
     gMessageSystem->addString("DirectoryVisibility", directory_visibility);
     gAgent.sendReliableMessage();
 
diff --git a/indra/newview/llagent.h b/indra/newview/llagent.h
index 134540c6b3..498bea3c07 100644
--- a/indra/newview/llagent.h
+++ b/indra/newview/llagent.h
@@ -928,14 +928,14 @@ public:
 	void 			sendAgentUserInfoRequest();
 
 // IM to Email and Online visibility
-	void			sendAgentUpdateUserInfo(bool im_to_email, const std::string& directory_visibility);
+	void			sendAgentUpdateUserInfo(const std::string& directory_visibility);
 
 private:
     void            requestAgentUserInfoCoro(std::string capurl);
-    void            updateAgentUserInfoCoro(std::string capurl, bool im_via_email, std::string directory_visibility);
+    void            updateAgentUserInfoCoro(std::string capurl, std::string directory_visibility);
     // DEPRECATED: may be removed when User Info cap propagates 
     void 			sendAgentUserInfoRequestMessage();
-    void            sendAgentUpdateUserInfoMessage(bool im_via_email, const std::string& directory_visibility);
+    void            sendAgentUpdateUserInfoMessage(const std::string& directory_visibility);
 
 	//--------------------------------------------------------------------
 	// Receive
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 5ca935518e..c1088468d9 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -101,6 +101,7 @@
 #include "lllogininstance.h"
 #include "llprogressview.h"
 #include "llvocache.h"
+#include "lldiskcache.h"
 #include "llvopartgroup.h"
 #include "llweb.h"
 #include "llfloatertexturefetchdebugger.h"
@@ -118,8 +119,6 @@
 #include "llprimitive.h"
 #include "llurlaction.h"
 #include "llurlentry.h"
-#include "llvfile.h"
-#include "llvfsthread.h"
 #include "llvolumemgr.h"
 #include "llxfermanager.h"
 #include "llphysicsextensions.h"
@@ -343,9 +342,6 @@ bool			gUseWireframe = FALSE;
 //use for remember deferred mode in wireframe switch
 bool			gInitialDeferredModeForWireframe = FALSE;
 
-// VFS globals - see llappviewer.h
-LLVFS* gStaticVFS = NULL;
-
 LLMemoryInfo gSysMemory;
 U64Bytes gMemoryAllocated(0); // updated in display_stats() in llviewerdisplay.cpp
 
@@ -434,12 +430,6 @@ void init_default_trans_args()
 	default_trans_args.insert("create_account_url");
 }
 
-//----------------------------------------------------------------------------
-// File scope definitons
-const char *VFS_DATA_FILE_BASE = "data.db2.x.";
-const char *VFS_INDEX_FILE_BASE = "index.db2.x.";
-
-
 struct SettingsFile : public LLInitParam::Block<SettingsFile>
 {
 	Mandatory<std::string>	name;
@@ -608,10 +598,10 @@ static void settings_to_globals()
 
 static void settings_modify()
 {
-	LLRenderTarget::sUseFBO				= gSavedSettings.getBOOL("RenderDeferred");
 	LLPipeline::sRenderTransparentWater	= gSavedSettings.getBOOL("RenderTransparentWater");
 	LLPipeline::sRenderBump				= gSavedSettings.getBOOL("RenderObjectBump");
-	LLPipeline::sRenderDeferred		= LLPipeline::sRenderTransparentWater && LLPipeline::sRenderBump && gSavedSettings.getBOOL("RenderDeferred");
+	LLPipeline::sRenderDeferred = LLPipeline::sRenderTransparentWater && LLPipeline::sRenderBump && gSavedSettings.getBOOL("RenderDeferred");
+    LLRenderTarget::sUseFBO = LLPipeline::sRenderDeferred && gSavedSettings.getBOOL("RenderAvatarVP");
 	LLVOSurfacePatch::sLODFactor		= gSavedSettings.getF32("RenderTerrainLODFactor");
 	LLVOSurfacePatch::sLODFactor *= LLVOSurfacePatch::sLODFactor; //square lod factor to get exponential range of [1,4]
 	gDebugGL = gSavedSettings.getBOOL("RenderDebugGL") || gDebugSession;
@@ -667,6 +657,7 @@ LLAppViewer* LLAppViewer::sInstance = NULL;
 LLTextureCache* LLAppViewer::sTextureCache = NULL;
 LLImageDecodeThread* LLAppViewer::sImageDecodeThread = NULL;
 LLTextureFetch* LLAppViewer::sTextureFetch = NULL;
+LLPurgeDiskCacheThread* LLAppViewer::sPurgeDiskCacheThread = NULL;
 
 std::string getRuntime()
 {
@@ -963,10 +954,6 @@ bool LLAppViewer::init()
 
 	// *Note: this is where gViewerStats used to be created.
 
-	//
-	// Initialize the VFS, and gracefully handle initialization errors
-	//
-
 	if (!initCache())
 	{
 		LL_WARNS("InitInfo") << "Failed to init cache" << LL_ENDL;
@@ -1380,7 +1367,6 @@ static LLTrace::BlockTimerStatHandle FTM_TEXTURE_CACHE("Texture Cache");
 static LLTrace::BlockTimerStatHandle FTM_DECODE("Image Decode");
 static LLTrace::BlockTimerStatHandle FTM_FETCH("Image Fetch");
 
-static LLTrace::BlockTimerStatHandle FTM_VFS("VFS Thread");
 static LLTrace::BlockTimerStatHandle FTM_LFS("LFS Thread");
 static LLTrace::BlockTimerStatHandle FTM_PAUSE_THREADS("Pause Threads");
 static LLTrace::BlockTimerStatHandle FTM_IDLE("Idle");
@@ -1619,17 +1605,13 @@ bool LLAppViewer::doFrame()
 				work_pending += updateTextureThreads(max_time);
 
 				{
-					LL_RECORD_BLOCK_TIME(FTM_VFS);
- 					io_pending += LLVFSThread::updateClass(1);
-				}
-				{
 					LL_RECORD_BLOCK_TIME(FTM_LFS);
  					io_pending += LLLFSThread::updateClass(1);
 				}
 
 				if (io_pending > 1000)
 				{
-					ms_sleep(llmin(io_pending/100,100)); // give the vfs some time to catch up
+					ms_sleep(llmin(io_pending/100,100)); // give the lfs some time to catch up
 				}
 
 				total_work_pending += work_pending ;
@@ -1646,7 +1628,6 @@ bool LLAppViewer::doFrame()
 			}
 			if(!total_io_pending) //pause file threads if nothing to process.
 			{
-				LLVFSThread::sLocal->pause();
 				LLLFSThread::sLocal->pause();
 			}
 
@@ -1711,12 +1692,11 @@ S32 LLAppViewer::updateTextureThreads(F32 max_time)
 	return work_pending;
 }
 
-void LLAppViewer::flushVFSIO()
+void LLAppViewer::flushLFSIO()
 {
 	while (1)
 	{
-		S32 pending = LLVFSThread::updateClass(0);
-		pending += LLLFSThread::updateClass(0);
+		S32 pending = LLLFSThread::updateClass(0);
 		if (!pending)
 		{
 			break;
@@ -1810,7 +1790,7 @@ bool LLAppViewer::cleanup()
 
 	LLKeyframeDataCache::clear();
 
- 	// End TransferManager before deleting systems it depends on (Audio, VFS, AssetStorage)
+ 	// End TransferManager before deleting systems it depends on (Audio, AssetStorage)
 #if 0 // this seems to get us stuck in an infinite loop...
 	gTransferManager.cleanup();
 #endif
@@ -1877,8 +1857,8 @@ bool LLAppViewer::cleanup()
 
 	LL_INFOS() << "Cache files removed" << LL_ENDL;
 
-	// Wait for any pending VFS IO
-	flushVFSIO();
+	// Wait for any pending LFS IO
+	flushLFSIO();
 	LL_INFOS() << "Shutting down Views" << LL_ENDL;
 
 	// Destroy the UI
@@ -1962,15 +1942,6 @@ bool LLAppViewer::cleanup()
 	SUBSYSTEM_CLEANUP(LLWorldMapView);
 	SUBSYSTEM_CLEANUP(LLFolderViewItem);
 
-	//
-	// Shut down the VFS's AFTER the decode manager cleans up (since it cleans up vfiles).
-	// Also after viewerwindow is deleted, since it may have image pointers (which have vfiles)
-	// Also after shutting down the messaging system since it has VFS dependencies
-
-	//
-	LL_INFOS() << "Cleaning up VFS" << LL_ENDL;
-	SUBSYSTEM_CLEANUP(LLVFile);
-
 	LL_INFOS() << "Saving Data" << LL_ENDL;
 
 	// Store the time of our current logoff
@@ -2059,7 +2030,6 @@ bool LLAppViewer::cleanup()
 		pending += LLAppViewer::getTextureCache()->update(1); // unpauses the worker thread
 		pending += LLAppViewer::getImageDecodeThread()->update(1); // unpauses the image thread
 		pending += LLAppViewer::getTextureFetch()->update(1); // unpauses the texture fetch thread
-		pending += LLVFSThread::updateClass(0);
 		pending += LLLFSThread::updateClass(0);
 		F64 idle_time = idleTimer.getElapsedTimeF64();
 		if(!pending)
@@ -2087,6 +2057,7 @@ bool LLAppViewer::cleanup()
 	sTextureFetch->shutdown();
 	sTextureCache->shutdown();
 	sImageDecodeThread->shutdown();
+	sPurgeDiskCacheThread->shutdown();
 
 	sTextureFetch->shutDownTextureCacheThread() ;
 	sTextureFetch->shutDownImageDecodeThread() ;
@@ -2109,6 +2080,8 @@ bool LLAppViewer::cleanup()
     sImageDecodeThread = NULL;
 	delete mFastTimerLogThread;
 	mFastTimerLogThread = NULL;
+	delete sPurgeDiskCacheThread;
+	sPurgeDiskCacheThread = NULL;
 
 	if (LLFastTimerView::sAnalyzePerformance)
 	{
@@ -2134,28 +2107,11 @@ bool LLAppViewer::cleanup()
 	gTextureList.shutdown(); // shutdown again in case a callback added something
 	LLUIImageList::getInstance()->cleanUp();
 
-	// This should eventually be done in LLAppViewer
 	SUBSYSTEM_CLEANUP(LLImage);
-	SUBSYSTEM_CLEANUP(LLVFSThread);
 	SUBSYSTEM_CLEANUP(LLLFSThread);
 
-#ifndef LL_RELEASE_FOR_DOWNLOAD
-	LL_INFOS() << "Auditing VFS" << LL_ENDL;
-	if(gVFS)
-	{
-		gVFS->audit();
-	}
-#endif
-
 	LL_INFOS() << "Misc Cleanup" << LL_ENDL;
 
-	// For safety, the LLVFS has to be deleted *after* LLVFSThread. This should be cleaned up.
-	// (LLVFS doesn't know about LLVFSThread so can't kill pending requests) -Steve
-	delete gStaticVFS;
-	gStaticVFS = NULL;
-	delete gVFS;
-	gVFS = NULL;
-
 	gSavedSettings.cleanup();
 	LLUIColorTable::instance().clear();
 
@@ -2215,7 +2171,6 @@ bool LLAppViewer::initThreads()
 
 	LLImage::initClass(gSavedSettings.getBOOL("TextureNewByteRange"),gSavedSettings.getS32("TextureReverseByteRange"));
 
-	LLVFSThread::initClass(enable_threads && false);
 	LLLFSThread::initClass(enable_threads && false);
 
 	// Image decoding
@@ -2225,6 +2180,7 @@ bool LLAppViewer::initThreads()
 													sImageDecodeThread,
 													enable_threads && true,
 													app_metrics_qa_mode);
+	LLAppViewer::sPurgeDiskCacheThread = new LLPurgeDiskCacheThread();
 
 	if (LLTrace::BlockTimer::sLog || LLTrace::BlockTimer::sMetricLog)
 	{
@@ -3242,10 +3198,6 @@ LLSD LLAppViewer::getViewerInfo() const
     info["GPU_SHADERS"] = gSavedSettings.getBOOL("RenderDeferred") ? "Enabled" : "Disabled";
     info["TEXTURE_MEMORY"] = gSavedSettings.getS32("TextureMemory");
 
-    LLSD substitution;
-    substitution["datetime"] = (S32)(gVFS ? gVFS->creationTime() : 0);
-    info["VFS_TIME"] = LLTrans::getString("AboutTime", substitution);
-
 #if LL_DARWIN
     info["HIDPI"] = gHiDPISupport;
 #endif
@@ -3337,6 +3289,9 @@ LLSD LLAppViewer::getViewerInfo() const
 		info["SERVER_RELEASE_NOTES_URL"] = mServerReleaseNotesURL;
 	}
 
+    // populate field for new local disk cache with some details
+    info["DISK_CACHE_INFO"] = LLDiskCache::getInstance()->getCacheInfo();
+
 	return info;
 }
 
@@ -4015,7 +3970,7 @@ void LLAppViewer::forceQuit()
 void LLAppViewer::fastQuit(S32 error_code)
 {
 	// finish pending transfers
-	flushVFSIO();
+	flushLFSIO();
 	// let sim know we're logging out
 	sendLogoutRequest();
 	// flush network buffers by shutting down messaging system
@@ -4204,44 +4159,14 @@ void LLAppViewer::migrateCacheDirectory()
 #endif // LL_WINDOWS || LL_DARWIN
 }
 
-void dumpVFSCaches()
-{
-	LL_INFOS() << "======= Static VFS ========" << LL_ENDL;
-	gStaticVFS->listFiles();
-#if LL_WINDOWS
-	LL_INFOS() << "======= Dumping static VFS to StaticVFSDump ========" << LL_ENDL;
-	WCHAR w_str[MAX_PATH];
-	GetCurrentDirectory(MAX_PATH, w_str);
-	S32 res = LLFile::mkdir("StaticVFSDump");
-	if (res == -1)
-	{
-		LL_WARNS() << "Couldn't create dir StaticVFSDump" << LL_ENDL;
-	}
-	SetCurrentDirectory(utf8str_to_utf16str("StaticVFSDump").c_str());
-	gStaticVFS->dumpFiles();
-	SetCurrentDirectory(w_str);
-#endif
-
-	LL_INFOS() << "========= Dynamic VFS ====" << LL_ENDL;
-	gVFS->listFiles();
-#if LL_WINDOWS
-	LL_INFOS() << "========= Dumping dynamic VFS to VFSDump ====" << LL_ENDL;
-	res = LLFile::mkdir("VFSDump");
-	if (res == -1)
-	{
-		LL_WARNS() << "Couldn't create dir VFSDump" << LL_ENDL;
-	}
-	SetCurrentDirectory(utf8str_to_utf16str("VFSDump").c_str());
-	gVFS->dumpFiles();
-	SetCurrentDirectory(w_str);
-#endif
-}
-
 //static
 U32 LLAppViewer::getTextureCacheVersion()
 {
-	//viewer texture cache version, change if the texture cache format changes.
-	const U32 TEXTURE_CACHE_VERSION = 8;
+	// Viewer texture cache version, change if the texture cache format changes.
+	// 2021-03-10 Bumping up by one to help obviate texture cache issues with
+	//            Simple Cache Viewer - see SL-14985 for more information
+	//const U32 TEXTURE_CACHE_VERSION = 8;
+	const U32 TEXTURE_CACHE_VERSION = 9;
 
 	return TEXTURE_CACHE_VERSION ;
 }
@@ -4263,6 +4188,17 @@ bool LLAppViewer::initCache()
 	LLAppViewer::getTextureCache()->setReadOnly(read_only) ;
 	LLVOCache::initParamSingleton(read_only);
 
+	// initialize the new disk cache using saved settings
+	const std::string cache_dir_name = gSavedSettings.getString("DiskCacheDirName");
+
+    // note that the maximum size of this cache is defined as a percentage of the 
+    // total cache size - the 'CacheSize' pref - for all caches. 
+    const unsigned int cache_total_size_mb = gSavedSettings.getU32("CacheSize");
+    const double disk_cache_percent = gSavedSettings.getF32("DiskCachePercentOfTotal");
+    const unsigned int disk_cache_mb = cache_total_size_mb * disk_cache_percent / 100;
+    const uintmax_t disk_cache_bytes = disk_cache_mb * 1024 * 1024;
+	const bool enable_cache_debug_info = gSavedSettings.getBOOL("EnableDiskCacheDebugInfo");
+
 	bool texture_cache_mismatch = false;
 	if (gSavedSettings.getS32("LocalCacheVersion") != LLAppViewer::getTextureCacheVersion())
 	{
@@ -4297,6 +4233,7 @@ bool LLAppViewer::initCache()
 			LL_INFOS("AppCache") << "Cache location changed, cache needs purging" << LL_ENDL;
 			gDirUtilp->setCacheDir(gSavedSettings.getString("CacheLocation"));
 			purgeCache(); // purge old cache
+			gDirUtilp->deleteDirAndContents(gDirUtilp->getExpandedFilename(LL_PATH_CACHE, cache_dir_name));
 			gSavedSettings.setString("CacheLocation", new_cache_location);
 			gSavedSettings.setString("CacheLocationTopFolder", gDirUtilp->getBaseFileName(new_cache_location));
 		}
@@ -4309,11 +4246,26 @@ bool LLAppViewer::initCache()
 		gSavedSettings.setString("CacheLocationTopFolder", "");
 	}
 
-	if (mPurgeCache && !read_only)
+	const std::string cache_dir = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, cache_dir_name);
+	LLDiskCache::initParamSingleton(cache_dir, disk_cache_bytes, enable_cache_debug_info);
+
+	if (!read_only)
 	{
-		LLSplashScreen::update(LLTrans::getString("StartupClearingCache"));
-		purgeCache();
+		if (mPurgeCache)
+		{
+			LLSplashScreen::update(LLTrans::getString("StartupClearingCache"));
+			purgeCache();
+
+			// clear the new C++ file system based cache
+			LLDiskCache::getInstance()->clearCache();
+		}
+		else
+		{
+			// purge excessive files from the new file system based cache
+			LLDiskCache::getInstance()->purge();
+		}
 	}
+	LLAppViewer::getPurgeDiskCacheThread()->start();
 
 	LLSplashScreen::update(LLTrans::getString("StartupInitializingTextureCache"));
 
@@ -4322,172 +4274,18 @@ bool LLAppViewer::initCache()
 	const S32 MB = 1024 * 1024;
 	const S64 MIN_CACHE_SIZE = 256 * MB;
 	const S64 MAX_CACHE_SIZE = 9984ll * MB;
-	const S64 MAX_VFS_SIZE = 1024 * MB; // 1 GB
 
 	S64 cache_size = (S64)(gSavedSettings.getU32("CacheSize")) * MB;
 	cache_size = llclamp(cache_size, MIN_CACHE_SIZE, MAX_CACHE_SIZE);
 
-	S64 vfs_size = llmin((S64)((cache_size * 2) / 10), MAX_VFS_SIZE);
-	S64 texture_cache_size = cache_size - vfs_size;
+	S64 texture_cache_size = cache_size;
 
 	S64 extra = LLAppViewer::getTextureCache()->initCache(LL_PATH_CACHE, texture_cache_size, texture_cache_mismatch);
 	texture_cache_size -= extra;
 
-
 	LLVOCache::getInstance()->initCache(LL_PATH_CACHE, gSavedSettings.getU32("CacheNumberOfRegionsForObjects"), getObjectCacheVersion());
 
-	LLSplashScreen::update(LLTrans::getString("StartupInitializingVFS"));
-
-	// Init the VFS
-	vfs_size = llmin(vfs_size + extra, MAX_VFS_SIZE);
-	vfs_size = (vfs_size / MB) * MB; // make sure it is MB aligned
-	U32 vfs_size_u32 = (U32)vfs_size;
-	U32 old_vfs_size = gSavedSettings.getU32("VFSOldSize") * MB;
-	bool resize_vfs = (vfs_size_u32 != old_vfs_size);
-	if (resize_vfs)
-	{
-		gSavedSettings.setU32("VFSOldSize", vfs_size_u32 / MB);
-	}
-	LL_INFOS("AppCache") << "VFS CACHE SIZE: " << vfs_size / (1024*1024) << " MB" << LL_ENDL;
-
-	// This has to happen BEFORE starting the vfs
-	// time_t	ltime;
-	srand(time(NULL));		// Flawfinder: ignore
-	U32 old_salt = gSavedSettings.getU32("VFSSalt");
-	U32 new_salt;
-	std::string old_vfs_data_file;
-	std::string old_vfs_index_file;
-	std::string new_vfs_data_file;
-	std::string new_vfs_index_file;
-	std::string static_vfs_index_file;
-	std::string static_vfs_data_file;
-
-	if (gSavedSettings.getBOOL("AllowMultipleViewers"))
-	{
-		// don't mess with renaming the VFS in this case
-		new_salt = old_salt;
-	}
-	else
-	{
-		do
-		{
-			new_salt = rand();
-		} while(new_salt == old_salt);
-	}
-
-	old_vfs_data_file = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, VFS_DATA_FILE_BASE) + llformat("%u", old_salt);
-
-	// make sure this file exists
-	llstat s;
-	S32 stat_result = LLFile::stat(old_vfs_data_file, &s);
-	if (stat_result)
-	{
-		// doesn't exist, look for a data file
-		std::string mask;
-		mask = VFS_DATA_FILE_BASE;
-		mask += "*";
-
-		std::string dir;
-		dir = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "");
-
-		std::string found_file;
-		LLDirIterator iter(dir, mask);
-		if (iter.next(found_file))
-		{
-			old_vfs_data_file = gDirUtilp->add(dir, found_file);
-
-			S32 start_pos = found_file.find_last_of('.');
-			if (start_pos > 0)
-			{
-				sscanf(found_file.substr(start_pos+1).c_str(), "%d", &old_salt);
-			}
-			LL_DEBUGS("AppCache") << "Default vfs data file not present, found: " << old_vfs_data_file << " Old salt: " << old_salt << LL_ENDL;
-		}
-	}
-
-	old_vfs_index_file = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, VFS_INDEX_FILE_BASE) + llformat("%u", old_salt);
-
-	stat_result = LLFile::stat(old_vfs_index_file, &s);
-	if (stat_result)
-	{
-		// We've got a bad/missing index file, nukem!
-		LL_WARNS("AppCache") << "Bad or missing vfx index file " << old_vfs_index_file << LL_ENDL;
-		LL_WARNS("AppCache") << "Removing old vfs data file " << old_vfs_data_file << LL_ENDL;
-		LLFile::remove(old_vfs_data_file);
-		LLFile::remove(old_vfs_index_file);
-
-		// Just in case, nuke any other old cache files in the directory.
-		std::string dir;
-		dir = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "");
-
-		std::string mask;
-		mask = VFS_DATA_FILE_BASE;
-		mask += "*";
-
-		gDirUtilp->deleteFilesInDir(dir, mask);
-
-		mask = VFS_INDEX_FILE_BASE;
-		mask += "*";
-
-		gDirUtilp->deleteFilesInDir(dir, mask);
-	}
-
-	new_vfs_data_file = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, VFS_DATA_FILE_BASE) + llformat("%u", new_salt);
-	new_vfs_index_file = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, VFS_INDEX_FILE_BASE) + llformat("%u", new_salt);
-
-	static_vfs_data_file = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "static_data.db2");
-	static_vfs_index_file = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "static_index.db2");
-
-	if (resize_vfs)
-	{
-		LL_DEBUGS("AppCache") << "Removing old vfs and re-sizing" << LL_ENDL;
-
-		LLFile::remove(old_vfs_data_file);
-		LLFile::remove(old_vfs_index_file);
-	}
-	else if (old_salt != new_salt)
-	{
-		// move the vfs files to a new name before opening
-		LL_DEBUGS("AppCache") << "Renaming " << old_vfs_data_file << " to " << new_vfs_data_file << LL_ENDL;
-		LL_DEBUGS("AppCache") << "Renaming " << old_vfs_index_file << " to " << new_vfs_index_file << LL_ENDL;
-		LLFile::rename(old_vfs_data_file, new_vfs_data_file);
-		LLFile::rename(old_vfs_index_file, new_vfs_index_file);
-	}
-
-	// Startup the VFS...
-	gSavedSettings.setU32("VFSSalt", new_salt);
-
-	// Don't remove VFS after viewer crashes.  If user has corrupt data, they can reinstall. JC
-	gVFS = LLVFS::createLLVFS(new_vfs_index_file, new_vfs_data_file, false, vfs_size_u32, false);
-	if (!gVFS)
-	{
-		return false;
-	}
-
-	gStaticVFS = LLVFS::createLLVFS(static_vfs_index_file, static_vfs_data_file, true, 0, false);
-	if (!gStaticVFS)
-	{
-		return false;
-	}
-
-	BOOL success = gVFS->isValid() && gStaticVFS->isValid();
-	if (!success)
-	{
-		return false;
-	}
-	else
-	{
-		LLVFile::initClass();
-
-#ifndef LL_RELEASE_FOR_DOWNLOAD
-		if (gSavedSettings.getBOOL("DumpVFSCaches"))
-		{
-			dumpVFSCaches();
-		}
-#endif
-
-		return true;
-	}
+    return true;
 }
 
 void LLAppViewer::addOnIdleCallback(const boost::function<void()>& cb)
diff --git a/indra/newview/llappviewer.h b/indra/newview/llappviewer.h
index 95f6efa29a..0f06889d20 100644
--- a/indra/newview/llappviewer.h
+++ b/indra/newview/llappviewer.h
@@ -1,5 +1,6 @@
 /** 
  * @mainpage
+ * @mainpage
  *
  * This is the sources for the Second Life Viewer;
  * information on the open source project is at 
@@ -57,6 +58,7 @@ class LLImageDecodeThread;
 class LLTextureFetch;
 class LLWatchdogTimeout;
 class LLViewerJoystick;
+class LLPurgeDiskCacheThread;
 class LLViewerRegion;
 
 extern LLTrace::BlockTimerStatHandle FTM_FRAME;
@@ -83,7 +85,7 @@ public:
 	virtual bool frame(); // Override for application body logic
 
 	// Application control
-	void flushVFSIO(); // waits for vfs transfers to complete
+	void flushLFSIO(); // waits for lfs transfers to complete
 	void forceQuit(); // Puts the viewer into 'shutting down without error' mode.
 	void fastQuit(S32 error_code = 0); // Shuts down the viewer immediately after sending a logout message
 	void requestQuit(); // Request a quit. A kinder, gentler quit.
@@ -116,6 +118,7 @@ public:
 	static LLTextureCache* getTextureCache() { return sTextureCache; }
 	static LLImageDecodeThread* getImageDecodeThread() { return sImageDecodeThread; }
 	static LLTextureFetch* getTextureFetch() { return sTextureFetch; }
+	static LLPurgeDiskCacheThread* getPurgeDiskCacheThread() { return sPurgeDiskCacheThread; }
 
 	static U32 getTextureCacheVersion() ;
 	static U32 getObjectCacheVersion() ;
@@ -284,6 +287,7 @@ private:
 	static LLTextureCache* sTextureCache; 
 	static LLImageDecodeThread* sImageDecodeThread; 
 	static LLTextureFetch* sTextureFetch;
+	static LLPurgeDiskCacheThread* sPurgeDiskCacheThread;
 
 	S32 mNumSessions;
 
@@ -382,12 +386,6 @@ extern BOOL			gRestoreGL;
 extern bool		gUseWireframe;
 extern bool		gInitialDeferredModeForWireframe;
 
-// VFS globals - gVFS is for general use
-// gStaticVFS is read-only and is shipped w/ the viewer
-// it has pre-cache data like the UI .TGAs
-class LLVFS;
-extern LLVFS	*gStaticVFS;
-
 extern LLMemoryInfo gSysMemory;
 extern U64Bytes gMemoryAllocated;
 
diff --git a/indra/newview/llappviewerwin32.cpp b/indra/newview/llappviewerwin32.cpp
index 5556ec8f76..ee533875b6 100644
--- a/indra/newview/llappviewerwin32.cpp
+++ b/indra/newview/llappviewerwin32.cpp
@@ -504,7 +504,7 @@ void LLAppViewerWin32::disableWinErrorReporting()
 	}
 }
 
-const S32 MAX_CONSOLE_LINES = 500;
+const S32 MAX_CONSOLE_LINES = 7500;
 // Only defined in newer SDKs than we currently use
 #ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
 #define ENABLE_VIRTUAL_TERMINAL_PROCESSING 4
diff --git a/indra/newview/llcompilequeue.cpp b/indra/newview/llcompilequeue.cpp
index bf10a9f2b4..9031ea5b1b 100644
--- a/indra/newview/llcompilequeue.cpp
+++ b/indra/newview/llcompilequeue.cpp
@@ -52,7 +52,7 @@
 #include "lldir.h"
 #include "llnotificationsutil.h"
 #include "llviewerstats.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
 #include "lluictrlfactory.h"
 #include "lltrans.h"
 
@@ -116,7 +116,7 @@ namespace
 }
 
 // *NOTE$: A minor specialization of LLScriptAssetUpload, it does not require a buffer 
-// (and does not save a buffer to the vFS) and it finds the compile queue window and 
+// (and does not save a buffer to the cache) and it finds the compile queue window and 
 // displays a compiling message.
 class LLQueuedScriptAssetUpload : public LLScriptAssetUpload
 {
@@ -134,8 +134,8 @@ public:
     virtual LLSD prepareUpload()
     {
         /* *NOTE$: The parent class (LLScriptAssetUpload will attempt to save 
-         * the script buffer into to the VFS.  Since the resource is already in 
-         * the VFS we don't want to do that.  Just put a compiling message in
+         * the script buffer into to the cache.  Since the resource is already in 
+         * the cache we don't want to do that.  Just put a compiling message in
          * the window and move on
          */
         LLFloaterCompileQueue* queue = LLFloaterReg::findTypedInstance<LLFloaterCompileQueue>("compile_queue", LLSD(mQueueId));
@@ -283,11 +283,11 @@ void LLFloaterCompileQueue::handleHTTPResponse(std::string pumpName, const LLSD
     LLEventPumps::instance().post(pumpName, expresult);
 }
 
-// *TODO: handleSCriptRetrieval is passed into the VFS via a legacy C function pointer
+// *TODO: handleSCriptRetrieval is passed into the cache via a legacy C function pointer
 // future project would be to convert these to C++ callables (std::function<>) so that 
 // we can use bind and remove the userData parameter.
 // 
-void LLFloaterCompileQueue::handleScriptRetrieval(LLVFS *vfs, const LLUUID& assetId, 
+void LLFloaterCompileQueue::handleScriptRetrieval(const LLUUID& assetId, 
     LLAssetType::EType type, void* userData, S32 status, LLExtStat extStatus)
 {
     LLSD result(LLSD::emptyMap());
diff --git a/indra/newview/llcompilequeue.h b/indra/newview/llcompilequeue.h
index adb854875a..a9bac345b5 100644
--- a/indra/newview/llcompilequeue.h
+++ b/indra/newview/llcompilequeue.h
@@ -135,7 +135,7 @@ protected:
 
     //bool checkAssetId(const LLUUID &assetId);
     static void handleHTTPResponse(std::string pumpName, const LLSD &expresult);
-    static void handleScriptRetrieval(LLVFS *vfs, const LLUUID& assetId, LLAssetType::EType type, void* userData, S32 status, LLExtStat extStatus);
+    static void handleScriptRetrieval(const LLUUID& assetId, LLAssetType::EType type, void* userData, S32 status, LLExtStat extStatus);
 
 private:
     static void processExperienceIdResults(LLSD result, LLUUID parent);
diff --git a/indra/newview/lldrawpoolavatar.cpp b/indra/newview/lldrawpoolavatar.cpp
index 61b357dd68..76cbe85b7e 100644
--- a/indra/newview/lldrawpoolavatar.cpp
+++ b/indra/newview/lldrawpoolavatar.cpp
@@ -1525,7 +1525,7 @@ void LLDrawPoolAvatar::renderAvatars(LLVOAvatar* single_avatar, S32 pass)
 	}
 
 	LLVOAvatar *attached_av = avatarp->getAttachedAvatar();
-	if (attached_av && LLVOAvatar::AOA_NORMAL != attached_av->getOverallAppearance())
+	if (attached_av && (LLVOAvatar::AOA_NORMAL != attached_av->getOverallAppearance() || !gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_AVATAR)))
 	{
 		// Animesh attachment of a jellydolled or invisible parent - don't show
 		return;
diff --git a/indra/newview/llfilepicker.h b/indra/newview/llfilepicker.h
index 2fc496a144..04ba4416d7 100644
--- a/indra/newview/llfilepicker.h
+++ b/indra/newview/llfilepicker.h
@@ -136,7 +136,7 @@ public:
 
 	S32 getFileCount() const { return (S32)mFiles.size(); }
 
-	// See llvfs/lldir.h : getBaseFileName and getDirName to extract base or directory names
+	// see lldir.h : getBaseFileName and getDirName to extract base or directory names
 	
 	// clear any lists of buffers or whatever, and make sure the file
 	// picker isn't locked.
diff --git a/indra/newview/llfloater360capture.cpp b/indra/newview/llfloater360capture.cpp
new file mode 100644
index 0000000000..745f154535
--- /dev/null
+++ b/indra/newview/llfloater360capture.cpp
@@ -0,0 +1,930 @@
+/**
+ * @file llfloater360capture.cpp
+ * @author Callum Prentice (callum@lindenlab.com)
+ * @brief Floater code for the 360 Capture feature
+ *
+ * $LicenseInfo:firstyear=2011&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2011, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "llfloater360capture.h"
+
+#include "llagent.h"
+#include "llagentui.h"
+#include "llbase64.h"
+#include "llcallbacklist.h"
+#include "llenvironment.h"
+#include "llimagejpeg.h"
+#include "llmediactrl.h"
+#include "llradiogroup.h"
+#include "llslurl.h"
+#include "lltextbox.h"
+#include "lltrans.h"
+#include "lluictrlfactory.h"
+#include "llversioninfo.h"
+#include "llviewercamera.h"
+#include "llviewercontrol.h"
+#include "llviewerpartsim.h"
+#include "llviewerregion.h"
+#include "llviewerwindow.h"
+#include "pipeline.h"
+
+#include <iterator>
+
+LLFloater360Capture::LLFloater360Capture(const LLSD& key)
+    :   LLFloater(key)
+{
+    // The handle to embedded browser that we use to
+    // render the WebGL preview as we as host the
+    // Cube Map to Equirectangular image code
+    mWebBrowser = nullptr;
+
+    // Ask the simulator to send us everything (and not just
+    // what it thinks the connected Viewer can see) until
+    // such time as we ask it not to (the dtor). If we crash or
+    // otherwise, exit before this is turned off, the Simulator
+    // will take care of cleaning up for us.
+    if (gSavedSettings.getBOOL("360CaptureUseInterestListCap"))
+    {
+        // send everything to us for as long as this floater is open
+        const bool send_everything = true;
+        changeInterestListMode(send_everything);
+    }
+}
+
+LLFloater360Capture::~LLFloater360Capture()
+{
+    if (mWebBrowser)
+    {
+        mWebBrowser->navigateStop();
+        mWebBrowser->clearCache();
+        mWebBrowser->unloadMediaSource();
+    }
+
+    // Tell the Simulator not to send us everything anymore
+    // and revert to the regular "keyhole" frustum of interest
+    // list updates.
+    if (gSavedSettings.getBOOL("360CaptureUseInterestListCap"))
+    {
+        const bool send_everything = false;
+        changeInterestListMode(send_everything);
+    }
+}
+
+BOOL LLFloater360Capture::postBuild()
+{
+    mCaptureBtn = getChild<LLUICtrl>("capture_button");
+    mCaptureBtn->setCommitCallback(boost::bind(&LLFloater360Capture::onCapture360ImagesBtn, this));
+
+    mSaveLocalBtn = getChild<LLUICtrl>("save_local_button");
+    mSaveLocalBtn->setCommitCallback(boost::bind(&LLFloater360Capture::onSaveLocalBtn, this));
+    mSaveLocalBtn->setEnabled(false);
+
+    mWebBrowser = getChild<LLMediaCtrl>("360capture_contents");
+    mWebBrowser->addObserver(this);
+
+    // There is a group of radio buttons that define the quality
+    // by each having a 'value' that is returns equal to the pixel
+    // size (width == height)
+    mQualityRadioGroup = getChild<LLRadioGroup>("360_quality_selection");
+    mQualityRadioGroup->setCommitCallback(boost::bind(&LLFloater360Capture::onChooseQualityRadioGroup, this));
+
+    // UX/UI called for preview mode (always the first index/option)
+    // by default each time vs restoring the last value
+    mQualityRadioGroup->setSelectedIndex(0);
+
+    // Construct a URL pointing to the first page to load. Although
+    // we do not use this page for anything (after some significant
+    // design changes), we retain the code to load the start page
+    // in case that changes again one day. It also makes sure the
+    // embedded browser is active and ready to go for when the real
+    // page with the 360 preview is navigated to.
+    std::string url = STRINGIZE(
+                          "file:///" <<
+                          getHTMLBaseFolder() <<
+                          mDefaultHTML
+                      );
+    mWebBrowser->navigateTo(url);
+
+    // initial pass at determining what size (width == height since
+    // the cube map images are square) we should capture at.
+    setSourceImageSize();
+
+    // the size of the output equirectangular image. The height of an EQR image
+    // is always 1/2 of the width so we should not store it but rather,
+    // calculate it from the width directly
+    mOutputImageWidth = gSavedSettings.getU32("360CaptureOutputImageWidth");
+    mOutputImageHeight = mOutputImageWidth / 2;
+
+    // enable resizing and enable for width and for height
+    enableResizeCtrls(true, true, true);
+
+    // initial heading that consumers of the equirectangular image
+    // (such as Facebook or Flickr) use to position initial view -
+    // we set during capture - stored as degrees (0..359)
+    mInitialHeadingDeg = 0.0;
+
+    // save directory in which to store the images (must obliviously be
+    // writable by the viewer). Also create it for users who haven't
+    // used the 360 feature before.
+    mImageSaveDir = gDirUtilp->getLindenUserDir() + gDirUtilp->getDirDelimiter() + "eqrimg";
+    LLFile::mkdir(mImageSaveDir);
+
+    // We do an initial capture when the floater is opened, albeit at a 'preview'
+    // quality level (really low resolution, but really fast)
+    onCapture360ImagesBtn();
+
+    return true;
+}
+
+// called when the user choose a quality level using
+// the buttons in the radio group
+void LLFloater360Capture::onChooseQualityRadioGroup()
+{
+    // set the size of the captured cube map images based
+    // on the quality level chosen
+    setSourceImageSize();
+}
+
+// Using a new capability, tell the simulator that we want it to send everything
+// it knows about and not just what is in front of the camera, in its view
+// frustum. We need this feature so that the contents of the region that appears
+// in the 6 snapshots which we cannot see and is normally not "considered", is
+// also rendered. Typically, this is turned on when the 360 capture floater is
+// opened and turned off when it is closed.
+// Note: for this version, we do not have a way to determine when "everything"
+// has arrived and has been rendered so for now, the proposal is that users
+// will need to experiment with the low resolution version and wait for some
+// (hopefully) small period of time while the full contents resolves.
+// Pass in a flag to ask the simulator/interest list to "send everything" or
+// not (the default mode)
+void LLFloater360Capture::changeInterestListMode(bool send_everything)
+{
+    LLSD body;
+
+    if (send_everything)
+    {
+        body["mode"] = LLSD::String("360");
+    }
+    else
+    {
+        body["mode"] = LLSD::String("default");
+    }
+
+    if (gAgent.requestPostCapability("InterestList", body, [](const LLSD & response)
+    {
+        LL_INFOS("360Capture") <<
+                               "InterestList capability responded: \n" <<
+                               ll_pretty_print_sd(response) <<
+                               LL_ENDL;
+    }))
+    {
+        LL_INFOS("360Capture") <<
+                               "Successfully posted an InterestList capability request with payload: \n" <<
+                               ll_pretty_print_sd(body) <<
+                               LL_ENDL;
+    }
+    else
+    {
+        LL_INFOS("360Capture") <<
+                               "Unable to post an InterestList capability request with payload: \n" <<
+                               ll_pretty_print_sd(body) <<
+                               LL_ENDL;
+    }
+}
+
+// There is is a setting (360CaptureSourceImageSize) that holds the size
+// (width == height since it's a square) of each of the 6 source snapshots.
+// However there are some known (and I dare say, some more unknown conditions
+// where the specified size is not possible and this function tries to figure it
+// out and change that setting to the optimal value for the current conditions.
+void LLFloater360Capture::setSourceImageSize()
+{
+    mSourceImageSize = mQualityRadioGroup->getSelectedValue().asInteger();
+
+    // If deferred rendering is off, we need to shrink the window we capture
+    // until it's smaller than the Viewer window dimensions.
+    if (!LLPipeline::sRenderDeferred)
+    {
+        LLRect window_rect = gViewerWindow->getWindowRectRaw();
+        S32 window_width = window_rect.getWidth();
+        S32 window_height = window_rect.getHeight();
+
+        // It's not possible (as I had hoped) to always render to an off screen
+        // buffer regardless of deferred rendering status so the next best
+        // option is to render to a buffer that is the size of the users app
+        // window.  Note, this was changed - before it chose the smallest
+        // power of 2 less than the window size - but since that meant a
+        // 1023 height app window would result in a 512 pixel capture, Maxim
+        // tried this and it does indeed appear to work.  Mayb need to revisit
+        // after the project viewer pass if people on low end graphics systems
+        // after having issues.
+        if (mSourceImageSize > window_width || mSourceImageSize > window_height)
+        {
+            mSourceImageSize = llmin(window_width, window_height, mSourceImageSize);
+            LL_INFOS("360Capture") << "Deferred rendering is forcing a smaller capture size: " << mSourceImageSize << LL_ENDL;
+        }
+
+        // there has to be an easier way than this to get the value
+        // from the radio group item at index 0. Why doesn't
+        // LLRadioGroup::getSelectedValue(int index) exist?
+        int index = mQualityRadioGroup->getSelectedIndex();
+        mQualityRadioGroup->setSelectedIndex(0);
+        int min_size = mQualityRadioGroup->getSelectedValue().asInteger();
+        mQualityRadioGroup->setSelectedIndex(index);
+
+        // If the maximum size we can support falls below a threshold then
+        // we should display a message in the log so we can try to debug
+        // why this is happening
+        if (mSourceImageSize < min_size)
+        {
+            LL_INFOS("360Capture") << "Small snapshot size due to deferred rendering and small app window" << LL_ENDL;
+        }
+    }
+}
+
+// This function shouldn't exist! We use the tooltip text from
+// the corresponding XUI file (floater_360capture.xml) as the
+// overlay text for the final web page to inform the user
+// about the quality level in play.  There ought to be a
+// UI function like LLView* getSelectedItemView() or similar
+// but as far as I can tell, there isn't so we have to resort
+// to finding it ourselves with this icky code..
+const std::string LLFloater360Capture::getSelectedQualityTooltip()
+{
+    // safey (or bravery?)
+    if (mQualityRadioGroup != nullptr)
+    {
+        // for all the child widgets for the radio group
+        // (just the radio buttons themselves I think)
+        for (child_list_const_reverse_iter_t iter = mQualityRadioGroup->getChildList()->rbegin();
+                iter != mQualityRadioGroup->getChildList()->rend();
+                ++iter)
+        {
+            // if we match the selected index (which we can get easily)
+            // with our position in the list of children
+            if (mQualityRadioGroup->getSelectedIndex() ==
+                    std::distance(mQualityRadioGroup->getChildList()->rend(), iter) - 1)
+            {
+                // return the plain old tooltip text
+                return (*iter)->getToolTip();
+            }
+        }
+    }
+
+    // if it's not found or not available, return an empty string
+    return std::string();
+}
+
+// Some of the 'magic' happens via a web page in an HTML directory
+// and this code provides a single point of reference for its' location
+const std::string LLFloater360Capture::getHTMLBaseFolder()
+{
+    std::string folder_name = gDirUtilp->getSkinDir();
+    folder_name += gDirUtilp->getDirDelimiter();
+    folder_name += "html";
+    folder_name += gDirUtilp->getDirDelimiter();
+    folder_name += "common";
+    folder_name += gDirUtilp->getDirDelimiter();
+    folder_name += "equirectangular";
+    folder_name += gDirUtilp->getDirDelimiter();
+
+    return folder_name;
+}
+
+// triggered when the 'capture' button in the UI is pressed
+void LLFloater360Capture::onCapture360ImagesBtn()
+{
+    // launch the main capture code in a coroutine so we can
+    // yield/suspend at some points to give the main UI
+    // thread a look-in occasionally.
+    LLCoros::instance().launch("capture360cap", [this]()
+    {
+        capture360Images();
+    });
+}
+
+// Gets the full path name for a given JavaScript file in the HTML folder. We
+// use this ultimately as a parameter to the main web app so it knows where to find
+// the JavaScript array containing the 6 cube map images, stored as data URLs
+const std::string LLFloater360Capture::makeFullPathToJS(const std::string filename)
+{
+    std::string full_js_path = mImageSaveDir;
+    full_js_path += gDirUtilp->getDirDelimiter();
+    full_js_path += filename;
+
+    return full_js_path;
+}
+
+// Write the header/prequel portion of the JavaScript array of data urls
+// that we use to store the cube map images in (so the web code can load
+// them without tweaking browser security - we'd have to do this if they
+// we stored as plain old images) This deliberately overwrites the old
+// one, if it exists
+void LLFloater360Capture::writeDataURLHeader(const std::string filename)
+{
+    llofstream file_handle(filename.c_str());
+    if (file_handle.is_open())
+    {
+        file_handle << "// cube map images for Second Life Viewer panorama 360 images" << std::endl;
+        file_handle.close();
+    }
+}
+
+// Write the footer/sequel portion of the JavaScript image code. When this is
+// called, the current file on disk will contain the header and the 6 data
+// URLs, each with a well specified name.  This final piece of JavaScript code
+// creates an array from those data URLs that the main application can
+// reference and read.
+void LLFloater360Capture::writeDataURLFooter(const std::string filename)
+{
+    llofstream file_handle(filename.c_str(), std::ios_base::app);
+    if (file_handle.is_open())
+    {
+        file_handle << "var cubemap_img_js = [" << std::endl;
+        file_handle << "    img_posx, img_negx," << std::endl;
+        file_handle << "    img_posy, img_negy," << std::endl;
+        file_handle << "    img_posz, img_negz," << std::endl;
+        file_handle << "];" << std::endl;
+
+        file_handle.close();
+    }
+}
+
+// Given a filename, a chunk of data (representing an image file) and the size
+// of the buffer, we create a BASE64 encoded string and use it to build a JavaScript
+// data URL that represents the image in a web browser environment
+bool LLFloater360Capture::writeDataURL(const std::string filename, const std::string prefix, U8* data, unsigned int data_len)
+{
+    LL_INFOS("360Capture") << "Writing data URL for " << prefix << " to " << filename << LL_ENDL;
+
+    const std::string data_url = LLBase64::encode(data, data_len);
+
+    llofstream file_handle(filename.c_str(), std::ios_base::app);
+    if (file_handle.is_open())
+    {
+        file_handle << "var img_";
+        file_handle << prefix;
+        file_handle << " = '";
+        file_handle << "data:image/jpeg; base64,";
+        file_handle << data_url;
+        file_handle << "'";
+        file_handle << std::endl;
+        file_handle.close();
+
+        return true;
+    }
+
+    return false;
+}
+
+// Encode the image from each of the 6 snapshots and save it out to
+// the JavaScript array of data URLs
+void LLFloater360Capture::encodeAndSave(LLPointer<LLImageRaw> raw_image, const std::string filename, const std::string prefix)
+{
+    // the default quality for the JPEG encoding is set quite high
+    // but this still seems to be a reasonable compromise for
+    // quality/size and is still much smaller than equivalent PNGs
+    int jpeg_encode_quality = gSavedSettings.getU32("360CaptureJPEGEncodeQuality");
+    LLPointer<LLImageJPEG> jpeg_image = new LLImageJPEG(jpeg_encode_quality);
+
+    // Actually encode the JPEG image. This is where a lot of time
+    // is spent now that the snapshot capture process has been
+    // optimized.  The encode_time parameter doesn't appear to be
+    // used anymore.
+    const int encode_time = 0;
+    bool resultjpeg = jpeg_image->encode(raw_image, encode_time);
+
+    if (resultjpeg)
+    {
+        // save individual cube map images as real JPEG files
+        // for debugging or curiosity) based on debug settings
+        if (gSavedSettings.getBOOL("360CaptureDebugSaveImage"))
+        {
+            const std::string jpeg_filename = STRINGIZE(
+                                                  gDirUtilp->getLindenUserDir() <<
+                                                  gDirUtilp->getDirDelimiter() <<
+                                                  "eqrimg" <<
+                                                  gDirUtilp->getDirDelimiter() <<
+                                                  prefix <<
+                                                  "." <<
+                                                  jpeg_image->getExtension()
+                                              );
+
+            LL_INFOS("360Capture") << "Saving debug JPEG image as " << jpeg_filename << LL_ENDL;
+            jpeg_image->save(jpeg_filename);
+        }
+
+        // actually write the JPEG image to disk as a data URL
+        writeDataURL(filename, prefix, jpeg_image->getData(), jpeg_image->getDataSize());
+    }
+}
+
+// Defer back to the main loop for a single rendered frame to give
+// the renderer a chance to update the UI if it is needed
+void LLFloater360Capture::suspendForAFrame()
+{
+    const U32 frame_count_delta = 1;
+    U32 curr_frame_count = LLFrameTimer::getFrameCount();
+    while (LLFrameTimer::getFrameCount() <= curr_frame_count + frame_count_delta)
+    {
+        llcoro::suspend();
+    }
+}
+
+// A debug version of the snapshot code that simply fills the
+// buffer with a pattern that can be used to investigate
+// issues with encoding and saving off each RAW image.
+// Probably not needed anymore but saving here just in case.
+void LLFloater360Capture::mockSnapShot(LLImageRaw* raw)
+{
+    unsigned int width = raw->getWidth();
+    unsigned int height = raw->getHeight();
+    unsigned int depth = raw->getComponents();
+    unsigned char* pixels = raw->getData();
+
+    for (int y = 0; y < height; y++)
+    {
+        for (int x = 0; x < width; x++)
+        {
+            unsigned long offset = y * width * depth + x * depth;
+            unsigned char red = x * 256 / width;
+            unsigned char green = y * 256 / height;
+            unsigned char blue = ((x + y) / 2) * 256 / (width + height) / 2;
+            pixels[offset + 0] = red;
+            pixels[offset + 1] = green;
+            pixels[offset + 2] = blue;
+        }
+    }
+}
+
+// The main code that actually captures all 6 images and then saves them out to
+// disk before navigating the embedded web browser to the page with the WebGL
+// application that consumes them and creates an EQR image. This code runs as a
+// coroutine so it can be suspended at certain points.
+void LLFloater360Capture::capture360Images()
+{
+    // recheck the size of the cube map source images in case it changed
+    // since it was set when we opened the floater
+    setSourceImageSize();
+
+    // disable buttons while we are capturing
+    mCaptureBtn->setEnabled(false);
+    mSaveLocalBtn->setEnabled(false);
+
+    bool render_attached_lights = LLPipeline::sRenderAttachedLights;
+    // determine whether or not to include avatar in the scene as we capture the 360 panorama
+    if (gSavedSettings.getBOOL("360CaptureHideAvatars"))
+    {
+        // Turn off the avatar if UI tells us to hide it.
+        // Note: the original call to gAvatar.hide(FALSE) did *not* hide
+        // attachments and so for most residents, there would be some debris
+        // left behind in the snapshot.
+        // Note: this toggles so if it set to on, this will turn it off and
+        // the subsequent call to the same thing after capture is finished
+        // will turn it back on again.  Similarly, for the case where it
+        // was set to off - I think this is what we need
+        LLPipeline::toggleRenderTypeControl(LLPipeline::RENDER_TYPE_AVATAR);
+        LLPipeline::toggleRenderTypeControl(LLPipeline::RENDER_TYPE_PARTICLES);
+        LLPipeline::sRenderAttachedLights = FALSE;
+    }
+
+    // these are the 6 directions we will point the camera - essentially,
+    // North, South, East, West, Up, Down
+    LLVector3 look_dirs[6] = { LLVector3(1, 0, 0), LLVector3(0, 1, 0), LLVector3(0, 0, 1), LLVector3(-1, 0, 0), LLVector3(0, -1, 0), LLVector3(0, 0, -1) };
+    LLVector3 look_upvecs[6] = { LLVector3(0, 0, 1), LLVector3(0, 0, 1), LLVector3(0, -1, 0), LLVector3(0, 0, 1), LLVector3(0, 0, 1), LLVector3(0, 1, 0) };
+
+    // save current view/camera settings so we can restore them afterwards
+    S32 old_occlusion = LLPipeline::sUseOcclusion;
+
+    // set new parameters specific to the 360 requirements
+    LLPipeline::sUseOcclusion = 0;
+    LLViewerCamera* camera = LLViewerCamera::getInstance();
+    F32 old_fov = camera->getView();
+    F32 old_aspect = camera->getAspect();
+    F32 old_yaw = camera->getYaw();
+
+    // stop the motion of as much of the world moving as much as we can
+    freezeWorld(true);
+
+    // Save the direction (in degrees) the camera is looking when we
+    // take the shot since that is what we write to image metadata
+    // 'GPano:InitialViewHeadingDegrees' field.
+    // We need to convert from the angle getYaw() gives us into something
+    // the XMP data field wants (N=0, E=90, S=180, W= 270 etc.)
+    mInitialHeadingDeg  = (360 + 90 - (int)(camera->getYaw() * RAD_TO_DEG)) % 360;
+    LL_INFOS("360Capture") << "Recording a heading of " << (int)(mInitialHeadingDeg) << LL_ENDL;
+
+    // camera constants for the square, cube map capture image
+    camera->setAspect(1.0); // must set aspect ratio first to avoid undesirable clamping of vertical FoV
+    camera->setView(F_PI_BY_TWO);
+    camera->yaw(0.0);
+
+    // record how many times we changed camera to try to understand the "all shots are the same issue"
+    unsigned int camera_changed_times = 0;
+
+    // the name of the JavaScript file written out that contains the 6 cube map images
+    // stored as a JavaScript array of data URLs.  If you change this filename, you must
+    // also change the corresponding entry in the HTML file that uses it -
+    // (newview/skins/default/html/common/equirectangular/display_eqr.html)
+    const std::string cumemap_js_filename("cubemap_img.js");
+
+    // construct the full path to this file - typically stored in the users'
+    // Second Life settings / username / eqrimg folder.
+    const std::string cubemap_js_full_path = makeFullPathToJS(cumemap_js_filename);
+
+    // Write the JavaScript file header (the top of the file before the
+    // declarations of the actual data URLs array).  In practice, all this writes
+    // is a comment - it's main purpose is to reset the file from the last time
+    // it was written
+    writeDataURLHeader(cubemap_js_full_path);
+
+    // the names of the prefixes we assign as the name to each data URL and are then
+    // consumed by the WebGL application. Nominally, they stand for positive and
+    // negative in the X/Y/Z directions.
+    static const std::string prefixes[6] =
+    {
+        "posx", "posz", "posy",
+        "negx", "negz", "negy",
+    };
+
+    // number of times to render the scene (display(..) inside
+    // the simple snapshot function in llViewerWindow.
+    // Note: rendering even just 1 more time (for a total of 2)
+    // has a dramatic effect on the scene contents and *much*
+    // less of it is missing. More investigation required
+    // but for the moment, this helps with missing content
+    // because of interest list issues.
+    int num_render_passes = gSavedSettings.getU32("360CaptureNumRenderPasses");
+
+    // time the encode process for later optimization
+    auto encode_time_total = 0.0;
+
+    // for each of the 6 directions we shoot...
+    for (int i = 0; i < 6; i++)
+    {
+        // these buffers are where the raw, captured pixels are stored and
+        // the first time we use them, we have to make a new one
+        if (mRawImages[i] == nullptr)
+        {
+            mRawImages[i] = new LLImageRaw(mSourceImageSize, mSourceImageSize, 3);
+        }
+        else
+            // subsequent capture with floater open so we resize the buffer from
+            // the previous run
+        {
+            // LLImageRaw deletes the old one via operator= but just to be
+            // sure, we delete its' large data member first...
+            mRawImages[i]->deleteData();
+            mRawImages[i] = new LLImageRaw(mSourceImageSize, mSourceImageSize, 3);
+        }
+
+        // set up camera to look in each direction
+        camera->lookDir(look_dirs[i], look_upvecs[i]);
+
+        // record if camera changed to try to understand the "all shots are the same issue"
+        if (camera->isChanged())
+        {
+            ++camera_changed_times;
+        }
+
+        // call the (very) simplified snapshot code that simply deals
+        // with a single image, no sub-images etc. but is very fast
+        gViewerWindow->simpleSnapshot(mRawImages[i],
+                                      mSourceImageSize, mSourceImageSize, num_render_passes);
+
+        // encode each image and write to disk while saving how long it took to do so
+        auto t_start = std::chrono::high_resolution_clock::now();
+        encodeAndSave(mRawImages[i], cubemap_js_full_path, prefixes[i]);
+        auto t_end = std::chrono::high_resolution_clock::now();
+        auto duration = std::chrono::duration_cast<std::chrono::duration<double>>(t_end - t_start);
+        encode_time_total += duration.count();
+
+        // ping the main loop in case the snapshot process takes a really long
+        // time and we get disconnected
+        LLAppViewer::instance()->pingMainloopTimeout("LLFloater360Capture::capture360Images");
+    }
+
+    // display time to encode all 6 images.  It tends to be a fairly linear
+    // time for each so we don't need to worry about displaying the time
+    // for each - this gives us plenty to use for optimizing
+    LL_INFOS("360Capture") <<
+                           "Time to encode and save 6 images was " <<
+                           encode_time_total <<
+                           " seconds" <<
+                           LL_ENDL;
+
+    // Write the JavaScript file footer (the bottom of the file after the
+    // declarations of the actual data URLs array). The footer comprises of
+    // a JavaScript array declaration that references the 6 data URLs generated
+    // previously and is what is referred to in the display HTML file
+    // (newview/skins/default/html/common/equirectangular/display_eqr.html)
+    writeDataURLFooter(cubemap_js_full_path);
+
+    // unfreeze the world now we have our shots
+    freezeWorld(false);
+
+    // restore original view/camera/avatar settings settings
+    camera->setAspect(old_aspect);
+    camera->setView(old_fov);
+    camera->yaw(old_yaw);
+    LLPipeline::sUseOcclusion = old_occlusion;
+
+    // if we toggled off the avatar because the Hide check box was ticked,
+    // we should toggle it back to where it was before we started the capture
+    if (gSavedSettings.getBOOL("360CaptureHideAvatars"))
+    {
+        LLPipeline::toggleRenderTypeControl(LLPipeline::RENDER_TYPE_AVATAR);
+        LLPipeline::toggleRenderTypeControl(LLPipeline::RENDER_TYPE_PARTICLES);
+        LLPipeline::sRenderAttachedLights = render_attached_lights;
+    }
+
+    // record that we missed some shots in the log for later debugging
+    // note: we use 5 and not 6 because the first shot isn't regarded
+    // as a change - only the subsequent 5 are
+    if (camera_changed_times < 5)
+    {
+        LL_INFOS("360Capture") << "Warning: we only captured " << camera_changed_times << " images." << LL_ENDL;
+    }
+
+    // now we have the 6 shots saved in a well specified location,
+    // we can load the web content that uses them
+    std::string url = "file:///" + getHTMLBaseFolder() + mEqrGenHTML;
+    mWebBrowser->navigateTo(url);
+
+    // page is loaded and ready so we can turn on the buttons again
+    mCaptureBtn->setEnabled(true);
+    mSaveLocalBtn->setEnabled(true);
+
+    // allow the UI to update by suspending and waiting for the
+    // main render loop to update the UI
+    suspendForAFrame();
+}
+
+// once the request is made to navigate to the web page containing the code
+// to process the 6 images into an EQR one, we have to wait for it to finish
+// loaded - we get a "navigate complete" event when that happens that we can act on
+void LLFloater360Capture::handleMediaEvent(LLPluginClassMedia* self, EMediaEvent event)
+{
+    switch (event)
+    {
+        // not used right now but retaining because this event might
+        // be useful for a feature I am hoping to add
+        case MEDIA_EVENT_LOCATION_CHANGED:
+            break;
+
+        // navigation in the browser completed
+        case MEDIA_EVENT_NAVIGATE_COMPLETE:
+        {
+            // Confirm that the navigation event does indeed apply to the
+            // page we are looking for. At the moment, this is the only
+            // one we care about so the test is superfluous but that might change.
+            std::string navigate_url = self->getNavigateURI();
+            if (navigate_url.find(mEqrGenHTML) != std::string::npos)
+            {
+                // this string is being passed across to the web so replace all the windows backslash
+                // characters with forward slashes or (I think) the backslashes are treated as escapes
+                std::replace(mImageSaveDir.begin(), mImageSaveDir.end(), '\\', '/');
+
+                // we store the camera FOV (field of view) in a saved setting since this feels
+                // like something it would be interesting to change and experiment with
+                int camera_fov = gSavedSettings.getU32("360CaptureCameraFOV");
+
+                // compose the overlay for the final web page that tells the user
+                // what level of quality the capture was taken with
+                std::string overlay_label = "'" + getSelectedQualityTooltip() + "'";
+
+                // so now our page is loaded and images are in place - call
+                // the JavaScript init script with some parameters to initialize
+                // the WebGL based preview
+                const std::string cmd = STRINGIZE(
+                                            "init("
+                                            << mOutputImageWidth
+                                            << ", "
+                                            << mOutputImageHeight
+                                            << ", "
+                                            << "'"
+                                            << mImageSaveDir
+                                            << "'"
+                                            << ", "
+                                            << camera_fov
+                                            << ", "
+                                            << LLViewerCamera::getInstance()->getYaw()
+                                            << ", "
+                                            << overlay_label
+                                            << ")"
+                                        );
+
+                // execute the command on the page
+                mWebBrowser->getMediaPlugin()->executeJavaScript(cmd);
+            }
+        }
+        break;
+
+        default:
+            break;
+    }
+}
+
+// called when the user wants to save the cube maps off to the final EQR image
+void LLFloater360Capture::onSaveLocalBtn()
+{
+    // region name and URL
+    std::string region_name; // no sensible default
+    std::string region_url("http://secondlife.com");
+    LLViewerRegion* region = gAgent.getRegion();
+    if (region)
+    {
+        // region names can (and do) contain characters that would make passing
+        // them into a JavaScript function problematic - single quotes for example
+        // so we must escape/encode both
+        region_name = region->getName();
+
+        // escaping/encoding is a minefield - let's just remove any offending characters from the region name
+        region_name.erase(std::remove(region_name.begin(), region_name.end(), '\''), region_name.end());
+        region_name.erase(std::remove(region_name.begin(), region_name.end(), '\"'), region_name.end());
+
+        // fortunately there is already an escaping function built into the SLURL generation code
+        LLSLURL slurl;
+        bool is_escaped = true;
+        LLAgentUI::buildSLURL(slurl, is_escaped);
+        region_url = slurl.getSLURLString();
+    }
+
+    // build suggested filename (the one that appears as the default
+    // in the Save dialog box)
+    const std::string suggested_filename = generate_proposed_filename();
+
+    // This string (the name of the product plus a truncated version number (no build))
+    // is used in the XMP block as the name of the generating and stitching software.
+    // We save the version number here and not in the more generic 'software' item
+    // because that might help us determine something about the image in the future.
+    const std::string client_version = STRINGIZE(
+                                           LLVersionInfo::instance().getChannel() <<
+                                           " " <<
+                                           LLVersionInfo::instance().getShortVersion()
+                                       );
+
+    // save the time the image was created. I don't know if this should be
+    // UTC/ZULU or the users' local time. It probably doesn't matter.
+    std::time_t result = std::time(nullptr);
+    std::string ctime_str = std::ctime(&result);
+    std::string time_str = ctime_str.substr(0, ctime_str.length() - 1);
+
+    // build the JavaScript data structure that is used to pass all the
+    // variables into the JavaScript function on the web page loaded into
+    // the embedded browser component of the floater.
+    const std::string xmp_details = STRINGIZE(
+                                        "{ " <<
+                                        "pano_version: '" << "2.2.1" << "', " <<
+                                        "software: '" << LLVersionInfo::instance().getChannel() << "', " <<
+                                        "capture_software: '" << client_version << "', " <<
+                                        "stitching_software: '" << client_version << "', " <<
+                                        "width: " << mOutputImageWidth << ", " <<
+                                        "height: " << mOutputImageHeight << ", " <<
+                                        "heading: " << mInitialHeadingDeg << ", " <<
+                                        "actual_source_image_size: " << mQualityRadioGroup->getSelectedValue().asInteger() << ", " <<
+                                        "scaled_source_image_size: " << mSourceImageSize << ", " <<
+                                        "first_photo_date: '" << time_str << "', " <<
+                                        "last_photo_date: '" << time_str << "', " <<
+                                        "region_name: '" << region_name << "', " <<
+                                        "region_url: '" << region_url << "', " <<
+                                        " }"
+                                    );
+
+    // build the JavaScript command to send to the web browser
+    const std::string cmd = "saveAsEqrImage(\"" + suggested_filename + "\", " + xmp_details + ")";
+
+    // send it to the browser instance, triggering the equirectangular capture
+    // process and complimentary offer to save the image
+    mWebBrowser->getMediaPlugin()->executeJavaScript(cmd);
+}
+
+// We capture all 6 images sequentially and if parts of the world are moving
+// E.G. clouds, water, objects - then we may get seams or discontinuities
+// when the images are combined to form the EQR image.  This code tries to
+// stop everything so we can shoot for seamless shots.  There is probably more
+// we can do here - e.g. waves in the water probably won't line up.
+void LLFloater360Capture::freezeWorld(bool enable)
+{
+    static bool clouds_scroll_paused = false;
+    if (enable)
+    {
+        // record the cloud scroll current value so we can restore it
+        clouds_scroll_paused = LLEnvironment::instance().isCloudScrollPaused();
+
+        // stop the clouds moving
+        LLEnvironment::instance().pauseCloudScroll();
+
+        // freeze all avatars
+        LLCharacter* avatarp;
+        for (std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin();
+                iter != LLCharacter::sInstances.end(); ++iter)
+        {
+            avatarp = *iter;
+            mAvatarPauseHandles.push_back(avatarp->requestPause());
+        }
+
+        // freeze everything else
+        gSavedSettings.setBOOL("FreezeTime", true);
+
+        // disable particle system
+        LLViewerPartSim::getInstance()->enable(false);
+    }
+    else // turning off freeze world mode, either temporarily or not.
+    {
+        // restart the clouds moving if they were not paused before
+        // we starting using the 360 capture floater
+        if (clouds_scroll_paused == false)
+        {
+            LLEnvironment::instance().resumeCloudScroll();
+        }
+
+        // thaw all avatars
+        mAvatarPauseHandles.clear();
+
+        // thaw everything else
+        gSavedSettings.setBOOL("FreezeTime", false);
+
+        //enable particle system
+        LLViewerPartSim::getInstance()->enable(true);
+    }
+}
+
+// Build the default filename that appears in the Save dialog box. We try
+// to encode some metadata about too (region name, EQR dimensions, capture
+// time) but the user if free to replace this with anything else before
+// the images is saved.
+const std::string LLFloater360Capture::generate_proposed_filename()
+{
+    std::ostringstream filename("");
+
+    // base name
+    filename << "sl360_";
+
+    LLViewerRegion* region = gAgent.getRegion();
+    if (region)
+    {
+        // this looks complex but it's straightforward - removes all non-alpha chars from a string
+        // which in this case is the SL region name - we use it as a proposed filename but the user is free to change
+        std::string region_name = region->getName();
+        std::replace_if(region_name.begin(), region_name.end(), std::not1(std::ptr_fun(isalnum)), '_');
+        if (region_name.length() > 0)
+        {
+            filename << region_name;
+            filename << "_";
+        }
+    }
+
+    // add in resolution to make it easier to tell what you captured later
+    filename << mOutputImageWidth;
+    filename << "x";
+    filename << mOutputImageHeight;
+    filename << "_";
+
+    // Add in the size of the source image (width == height since it was square)
+    // Might be useful later for quality comparisons
+    filename << mSourceImageSize;
+    filename << "_";
+
+    // add in the current HH-MM-SS (with leading 0's) so users can easily save many shots in same folder
+    std::time_t cur_epoch = std::time(nullptr);
+    std::tm* tm_time = std::localtime(&cur_epoch);
+    filename << std::setfill('0') << std::setw(4) << (tm_time->tm_year + 1900);
+    filename << std::setfill('0') << std::setw(2) << (tm_time->tm_mon + 1);
+    filename << std::setfill('0') << std::setw(2) << tm_time->tm_mday;
+    filename << "_";
+    filename << std::setfill('0') << std::setw(2) << tm_time->tm_hour;
+    filename << std::setfill('0') << std::setw(2) << tm_time->tm_min;
+    filename << std::setfill('0') << std::setw(2) << tm_time->tm_sec;
+
+    // the unusual way we save the output image (originates in the
+    // embedded browser and not the C++ code) means that the system
+    // appends ".jpeg" to the file automatically on macOS at least,
+    // so we only need to do it ourselves for windows.
+#if LL_WINDOWS
+    filename << ".jpg";
+#endif
+
+    return filename.str();
+}
diff --git a/indra/newview/llfloater360capture.h b/indra/newview/llfloater360capture.h
new file mode 100644
index 0000000000..6da7ee074a
--- /dev/null
+++ b/indra/newview/llfloater360capture.h
@@ -0,0 +1,97 @@
+/**
+ * @file llfloater360capture.h
+ * @author Callum Prentice (callum@lindenlab.com)
+ * @brief Floater for the 360 capture feature
+ *
+ * $LicenseInfo:firstyear=2011&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2011, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_FLOATER_360CAPTURE_H
+#define LL_FLOATER_360CAPTURE_H
+
+#include "llfloater.h"
+#include "llmediactrl.h"
+#include "llcharacter.h"
+
+class LLImageRaw;
+class LLTextBox;
+class LLRadioGroup;
+
+class LLFloater360Capture:
+    public LLFloater,
+    public LLViewerMediaObserver
+{
+        friend class LLFloaterReg;
+
+    private:
+        LLFloater360Capture(const LLSD& key);
+
+        ~LLFloater360Capture();
+        BOOL postBuild() override;
+        void handleMediaEvent(LLPluginClassMedia* self, EMediaEvent event) override;
+
+        void changeInterestListMode(bool send_everything);
+
+        const std::string getHTMLBaseFolder();
+        void capture360Images();
+
+        const std::string makeFullPathToJS(const std::string filename);
+        void writeDataURLHeader(const std::string filename);
+        void writeDataURLFooter(const std::string filename);
+        bool writeDataURL(const std::string filename, const std::string prefix, U8* data, unsigned int data_len);
+        void encodeAndSave(LLPointer<LLImageRaw> raw_image, const std::string filename, const std::string prefix);
+
+        std::vector<LLAnimPauseRequest> mAvatarPauseHandles;
+        void freezeWorld(bool enable);
+
+        void mockSnapShot(LLImageRaw* raw);
+
+        void suspendForAFrame();
+
+        const std::string generate_proposed_filename();
+
+        void setSourceImageSize();
+
+        LLMediaCtrl* mWebBrowser;
+        const std::string mDefaultHTML = "default.html";
+        const std::string mEqrGenHTML = "eqr_gen.html";
+
+        LLUICtrl* mCaptureBtn;
+        void onCapture360ImagesBtn();
+
+        void onSaveLocalBtn();
+        LLUICtrl* mSaveLocalBtn;
+
+        LLRadioGroup* mQualityRadioGroup;
+        void onChooseQualityRadioGroup();
+        const std::string getSelectedQualityTooltip();
+
+        int mSourceImageSize;
+        float mInitialHeadingDeg;
+        int mOutputImageWidth;
+        int mOutputImageHeight;
+        std::string mImageSaveDir;
+
+        LLPointer<LLImageRaw> mRawImages[6];
+};
+
+#endif  // LL_FLOATER_360CAPTURE_H
diff --git a/indra/newview/llfloaterauction.cpp b/indra/newview/llfloaterauction.cpp
index 957b2e1e8e..9813156bf2 100644
--- a/indra/newview/llfloaterauction.cpp
+++ b/indra/newview/llfloaterauction.cpp
@@ -32,8 +32,7 @@
 #include "llimagej2c.h"
 #include "llimagetga.h"
 #include "llparcel.h"
-#include "llvfile.h"
-#include "llvfs.h"
+#include "llfilesystem.h"
 #include "llwindow.h"
 #include "message.h"
 
@@ -202,7 +201,9 @@ void LLFloaterAuction::onClickSnapshot(void* data)
 
 		LLPointer<LLImageTGA> tga = new LLImageTGA;
 		tga->encode(raw);
-		LLVFile::writeFile(tga->getData(), tga->getDataSize(), gVFS, self->mImageID, LLAssetType::AT_IMAGE_TGA);
+
+		LLFileSystem tga_file(self->mImageID, LLAssetType::AT_IMAGE_TGA, LLFileSystem::WRITE);
+		tga_file.write(tga->getData(), tga->getDataSize());
 		
 		raw->biasedScaleToPowerOfTwo(LLViewerTexture::MAX_IMAGE_SIZE_DEFAULT);
 
@@ -210,7 +211,9 @@ void LLFloaterAuction::onClickSnapshot(void* data)
 
 		LLPointer<LLImageJ2C> j2c = new LLImageJ2C;
 		j2c->encode(raw, 0.0f);
-		LLVFile::writeFile(j2c->getData(), j2c->getDataSize(), gVFS, self->mImageID, LLAssetType::AT_TEXTURE);
+
+		LLFileSystem j2c_file(self->mImageID, LLAssetType::AT_TEXTURE, LLFileSystem::WRITE);
+		j2c_file.write(j2c->getData(), j2c->getDataSize());
 
 		self->mImage = LLViewerTextureManager::getLocalTexture((LLImageRaw*)raw, FALSE);
 		gGL.getTexUnit(0)->bind(self->mImage);
diff --git a/indra/newview/llfloaterbvhpreview.cpp b/indra/newview/llfloaterbvhpreview.cpp
index 131d9b077b..687d820a18 100644
--- a/indra/newview/llfloaterbvhpreview.cpp
+++ b/indra/newview/llfloaterbvhpreview.cpp
@@ -32,7 +32,7 @@
 #include "lldatapacker.h"
 #include "lldir.h"
 #include "llnotificationsutil.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
 #include "llapr.h"
 #include "llstring.h"
 
@@ -997,10 +997,9 @@ void LLFloaterBvhPreview::onBtnOK(void* userdata)
 		LLDataPackerBinaryBuffer dp(buffer, file_size);
 		if (motionp->serialize(dp))
 		{
-			LLVFile file(gVFS, motionp->getID(), LLAssetType::AT_ANIMATION, LLVFile::APPEND);
+			LLFileSystem file(motionp->getID(), LLAssetType::AT_ANIMATION, LLFileSystem::APPEND);
 
 			S32 size = dp.getCurrentSize();
-			file.setMaxSize(size);
 			if (file.write((U8*)buffer, size))
 			{
 				std::string name = floaterp->getChild<LLUICtrl>("name_form")->getValue().asString();
diff --git a/indra/newview/llfloatermodelpreview.cpp b/indra/newview/llfloatermodelpreview.cpp
index 1dbf0d84cb..abc64a7ad9 100644
--- a/indra/newview/llfloatermodelpreview.cpp
+++ b/indra/newview/llfloatermodelpreview.cpp
@@ -59,6 +59,7 @@
 #include "llspinctrl.h"
 #include "lltabcontainer.h"
 #include "lltrans.h"
+#include "llfilesystem.h"
 #include "llcallbacklist.h"
 #include "llviewertexteditor.h"
 #include "llviewernetwork.h"
diff --git a/indra/newview/llfloaterpreference.cpp b/indra/newview/llfloaterpreference.cpp
index 82f01fb747..da01457126 100644
--- a/indra/newview/llfloaterpreference.cpp
+++ b/indra/newview/llfloaterpreference.cpp
@@ -261,7 +261,6 @@ std::string LLFloaterPreference::sSkin = "";
 LLFloaterPreference::LLFloaterPreference(const LLSD& key)
 	: LLFloater(key),
 	mGotPersonalInfo(false),
-	mOriginalIMViaEmail(false),
 	mLanguageChanged(false),
 	mAvatarDataInitialized(false),
 	mSearchDataDirty(true)
@@ -557,11 +556,9 @@ void LLFloaterPreference::apply()
 	
 	if (mGotPersonalInfo)
 	{ 
-		bool new_im_via_email = getChild<LLUICtrl>("send_im_to_email")->getValue().asBoolean();
 		bool new_hide_online = getChild<LLUICtrl>("online_visibility")->getValue().asBoolean();		
 	
-		if ((new_im_via_email != mOriginalIMViaEmail)
-			||(new_hide_online != mOriginalHideOnlineStatus))
+		if (new_hide_online != mOriginalHideOnlineStatus)
 		{
 			// This hack is because we are representing several different 	 
 			// possible strings with a single checkbox. Since most users 	 
@@ -575,7 +572,7 @@ void LLFloaterPreference::apply()
 			 //Update showonline value, otherwise multiple applys won't work
 				mOriginalHideOnlineStatus = new_hide_online;
 			}
-			gAgent.sendAgentUpdateUserInfo(new_im_via_email,mDirectoryVisibility);
+			gAgent.sendAgentUpdateUserInfo(mDirectoryVisibility);
 		}
 	}
 
@@ -980,12 +977,12 @@ void LLFloaterPreference::onBtnCancel(const LLSD& userdata)
 }
 
 // static 
-void LLFloaterPreference::updateUserInfo(const std::string& visibility, bool im_via_email, bool is_verified_email)
+void LLFloaterPreference::updateUserInfo(const std::string& visibility)
 {
 	LLFloaterPreference* instance = LLFloaterReg::findTypedInstance<LLFloaterPreference>("preferences");
 	if (instance)
 	{
-        instance->setPersonalInfo(visibility, im_via_email, is_verified_email);
+        instance->setPersonalInfo(visibility);
 	}
 }
 
@@ -1694,10 +1691,9 @@ bool LLFloaterPreference::moveTranscriptsAndLog()
 	return true;
 }
 
-void LLFloaterPreference::setPersonalInfo(const std::string& visibility, bool im_via_email, bool is_verified_email)
+void LLFloaterPreference::setPersonalInfo(const std::string& visibility)
 {
 	mGotPersonalInfo = true;
-	mOriginalIMViaEmail = im_via_email;
 	mDirectoryVisibility = visibility;
 	
 	if (visibility == VISIBILITY_DEFAULT)
@@ -1719,16 +1715,7 @@ void LLFloaterPreference::setPersonalInfo(const std::string& visibility, bool im
 	getChildView("friends_online_notify_checkbox")->setEnabled(TRUE);
 	getChild<LLUICtrl>("online_visibility")->setValue(mOriginalHideOnlineStatus); 	 
 	getChild<LLUICtrl>("online_visibility")->setLabelArg("[DIR_VIS]", mDirectoryVisibility);
-	getChildView("send_im_to_email")->setEnabled(is_verified_email);
 
-    std::string tooltip;
-    if (!is_verified_email)
-        tooltip = getString("email_unverified_tooltip");
-
-    getChildView("send_im_to_email")->setToolTip(tooltip);
-
-    // *TODO: Show or hide verify email text here based on is_verified_email
-    getChild<LLUICtrl>("send_im_to_email")->setValue(im_via_email);
 	getChildView("favorites_on_login_check")->setEnabled(TRUE);
 	getChildView("log_path_button")->setEnabled(TRUE);
 	getChildView("chat_font_size")->setEnabled(TRUE);
diff --git a/indra/newview/llfloaterpreference.h b/indra/newview/llfloaterpreference.h
index e9e19e9acb..5ef2ca68d3 100644
--- a/indra/newview/llfloaterpreference.h
+++ b/indra/newview/llfloaterpreference.h
@@ -88,7 +88,7 @@ public:
 	/*virtual*/ void changed(const LLUUID& session_id, U32 mask) {};
 
 	// static data update, called from message handler
-	static void updateUserInfo(const std::string& visibility, bool im_via_email, bool is_verified_email);
+	static void updateUserInfo(const std::string& visibility);
 
 	// refresh all the graphics preferences menus
 	static void refreshEnabledGraphics();
@@ -114,7 +114,7 @@ protected:
 	void		onBtnOK(const LLSD& userdata);
 	void		onBtnCancel(const LLSD& userdata);
 
-	void		onClickClearCache();			// Clear viewer texture cache, vfs, and VO cache on next startup
+	void		onClickClearCache();			// Clear viewer texture cache, file cache on next startup
 	void		onClickBrowserClearCache();		// Clear web history and caches as well as viewer caches above
 	void		onLanguageChange();
 	void		onNotificationsChange(const std::string& OptionName);
@@ -160,7 +160,7 @@ public:
 	void changeLogPath(const std::vector<std::string>& filenames, std::string proposed_name);
 	bool moveTranscriptsAndLog();
 	void enableHistory();
-	void setPersonalInfo(const std::string& visibility, bool im_via_email, bool is_verified_email);
+	void setPersonalInfo(const std::string& visibility);
 	void refreshEnabledState();
 	void onCommitWindowedMode();
 	void refresh();	// Refresh enable/disable
@@ -206,7 +206,6 @@ private:
 	static std::string sSkin;
 	notifications_map mNotificationOptions;
 	bool mGotPersonalInfo;
-	bool mOriginalIMViaEmail;
 	bool mLanguageChanged;
 	bool mAvatarDataInitialized;
 	std::string mPriorInstantMessageLogPath;
diff --git a/indra/newview/llfloaterregioninfo.cpp b/indra/newview/llfloaterregioninfo.cpp
index 17e55b5f2c..19080f05c0 100644
--- a/indra/newview/llfloaterregioninfo.cpp
+++ b/indra/newview/llfloaterregioninfo.cpp
@@ -36,7 +36,7 @@
 #include "llglheaders.h"
 #include "llregionflags.h"
 #include "llstl.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
 #include "llxfermanager.h"
 #include "indra_constants.h"
 #include "message.h"
@@ -2252,10 +2252,9 @@ void LLPanelEstateCovenant::loadInvItem(LLInventoryItem *itemp)
 }
 
 // static
-void LLPanelEstateCovenant::onLoadComplete(LLVFS *vfs,
-									   const LLUUID& asset_uuid,
-									   LLAssetType::EType type,
-									   void* user_data, S32 status, LLExtStat ext_status)
+void LLPanelEstateCovenant::onLoadComplete(const LLUUID& asset_uuid,
+									       LLAssetType::EType type,
+									       void* user_data, S32 status, LLExtStat ext_status)
 {
 	LL_INFOS() << "LLPanelEstateCovenant::onLoadComplete()" << LL_ENDL;
 	LLPanelEstateCovenant* panelp = (LLPanelEstateCovenant*)user_data;
@@ -2263,7 +2262,7 @@ void LLPanelEstateCovenant::onLoadComplete(LLVFS *vfs,
 	{
 		if(0 == status)
 		{
-			LLVFile file(vfs, asset_uuid, type, LLVFile::READ);
+			LLFileSystem file(asset_uuid, type, LLFileSystem::READ);
 
 			S32 file_length = file.getSize();
 
diff --git a/indra/newview/llfloaterregioninfo.h b/indra/newview/llfloaterregioninfo.h
index 75d0c3ea5c..c34dbb62e8 100644
--- a/indra/newview/llfloaterregioninfo.h
+++ b/indra/newview/llfloaterregioninfo.h
@@ -55,7 +55,6 @@ class LLRadioGroup;
 class LLSliderCtrl;
 class LLSpinCtrl;
 class LLTextBox;
-class LLVFS;
 
 class LLPanelRegionGeneralInfo;
 class LLPanelRegionDebugInfo;
@@ -357,8 +356,7 @@ public:
 	static bool confirmResetCovenantCallback(const LLSD& notification, const LLSD& response);
 	void sendChangeCovenantID(const LLUUID &asset_id);
 	void loadInvItem(LLInventoryItem *itemp);
-	static void onLoadComplete(LLVFS *vfs,
-							   const LLUUID& asset_uuid,
+	static void onLoadComplete(const LLUUID& asset_uuid,
 							   LLAssetType::EType type,
 							   void* user_data, S32 status, LLExtStat ext_status);
 
diff --git a/indra/newview/llfloaterreporter.cpp b/indra/newview/llfloaterreporter.cpp
index a30c73768d..b73755cf4e 100644
--- a/indra/newview/llfloaterreporter.cpp
+++ b/indra/newview/llfloaterreporter.cpp
@@ -44,8 +44,7 @@
 #include "llnotificationsutil.h"
 #include "llstring.h"
 #include "llsys.h"
-#include "llvfile.h"
-#include "llvfs.h"
+#include "llfilesystem.h"
 #include "mean_collision_data.h"
 #include "message.h"
 #include "v3math.h"
@@ -896,12 +895,9 @@ void LLFloaterReporter::takeScreenshot(bool use_prev_screenshot)
 	mResourceDatap->mAssetInfo.setName("screenshot_name");
 	mResourceDatap->mAssetInfo.setDescription("screenshot_descr");
 
-	// store in VFS
-	LLVFile::writeFile(upload_data->getData(), 
-						upload_data->getDataSize(), 
-						gVFS, 
-						mResourceDatap->mAssetInfo.mUuid, 
-						mResourceDatap->mAssetInfo.mType);
+	// store in cache
+    LLFileSystem j2c_file(mResourceDatap->mAssetInfo.mUuid, mResourceDatap->mAssetInfo.mType, LLFileSystem::WRITE);
+    j2c_file.write(upload_data->getData(), upload_data->getDataSize());
 
 	// store in the image list so it doesn't try to fetch from the server
 	LLPointer<LLViewerFetchedTexture> image_in_list = 
diff --git a/indra/newview/llfloatersnapshot.cpp b/indra/newview/llfloatersnapshot.cpp
index ef7a9fd536..83212230e5 100644
--- a/indra/newview/llfloatersnapshot.cpp
+++ b/indra/newview/llfloatersnapshot.cpp
@@ -179,6 +179,10 @@ void LLFloaterSnapshotBase::ImplBase::updateLayout(LLFloaterSnapshotBase* floate
 	thumbnail_placeholder->reshape(panel_width, thumbnail_placeholder->getRect().getHeight());
 	floaterp->getChild<LLUICtrl>("image_res_text")->setVisible(mAdvanced);
 	floaterp->getChild<LLUICtrl>("file_size_label")->setVisible(mAdvanced);
+    if (floaterp->hasChild("360_label", TRUE))
+    { 
+        floaterp->getChild<LLUICtrl>("360_label")->setVisible(mAdvanced);
+    }
 	if(!floaterp->isMinimized())
 	{
 		floaterp->reshape(floater_width, floaterp->getRect().getHeight());
@@ -992,6 +996,10 @@ BOOL LLFloaterSnapshot::postBuild()
     getChild<LLButton>("retract_btn")->setCommitCallback(boost::bind(&LLFloaterSnapshot::onExtendFloater, this));
     getChild<LLButton>("extend_btn")->setCommitCallback(boost::bind(&LLFloaterSnapshot::onExtendFloater, this));
 
+    getChild<LLTextBox>("360_label")->setSoundFlags(LLView::MOUSE_UP);
+    getChild<LLTextBox>("360_label")->setShowCursorHand(false);
+    getChild<LLTextBox>("360_label")->setClickedCallback(boost::bind(&LLFloaterSnapshot::on360Snapshot, this));
+
 	// Filters
 	LLComboBox* filterbox = getChild<LLComboBox>("filters_combobox");
 	std::vector<std::string> filter_list = LLImageFiltersManager::getInstance()->getFiltersList();
@@ -1118,6 +1126,12 @@ void LLFloaterSnapshot::onExtendFloater()
 	impl->setAdvanced(gSavedSettings.getBOOL("AdvanceSnapshot"));
 }
 
+void LLFloaterSnapshot::on360Snapshot()
+{
+    LLFloaterReg::showInstance("360capture");
+    closeFloater();
+}
+
 //virtual
 void LLFloaterSnapshotBase::onClose(bool app_quitting)
 {
diff --git a/indra/newview/llfloatersnapshot.h b/indra/newview/llfloatersnapshot.h
index 8221b0a637..7ec133ff45 100644
--- a/indra/newview/llfloatersnapshot.h
+++ b/indra/newview/llfloatersnapshot.h
@@ -153,6 +153,7 @@ public:
 	static void update();
 
 	void onExtendFloater();
+    void on360Snapshot();
 
 	static LLFloaterSnapshot* getInstance();
 	static LLFloaterSnapshot* findInstance();
diff --git a/indra/newview/llfloatertos.cpp b/indra/newview/llfloatertos.cpp
index bd403f68d7..1aeb727172 100644
--- a/indra/newview/llfloatertos.cpp
+++ b/indra/newview/llfloatertos.cpp
@@ -40,7 +40,7 @@
 #include "lltextbox.h"
 #include "llui.h"
 #include "lluictrlfactory.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
 #include "message.h"
 #include "llstartup.h"              // login_alert_done
 #include "llcorehttputil.h"
diff --git a/indra/newview/llfloatertos.h b/indra/newview/llfloatertos.h
index 85033acf4d..7c2f0705b7 100644
--- a/indra/newview/llfloatertos.h
+++ b/indra/newview/llfloatertos.h
@@ -36,7 +36,6 @@
 
 class LLButton;
 class LLRadioGroup;
-class LLVFS;
 class LLTextEditor;
 class LLUUID;
 
diff --git a/indra/newview/llgesturemgr.cpp b/indra/newview/llgesturemgr.cpp
index 950a6cfaef..9f2119281d 100644
--- a/indra/newview/llgesturemgr.cpp
+++ b/indra/newview/llgesturemgr.cpp
@@ -42,7 +42,7 @@
 #include "llnotificationsutil.h"
 #include "llstl.h"
 #include "llstring.h"	// todo: remove
-#include "llvfile.h"
+#include "llfilesystem.h"
 #include "message.h"
 
 // newview
@@ -548,7 +548,7 @@ void LLGestureMgr::playGesture(LLMultiGesture* gesture)
 				LLGestureStepAnimation* anim_step = (LLGestureStepAnimation*)step;
 				const LLUUID& anim_id = anim_step->mAnimAssetID;
 
-				// Don't request the animation if this step stops it or if it is already in Static VFS
+				// Don't request the animation if this step stops it or if it is already in the cache
 				if (!(anim_id.isNull()
 					  || anim_step->mFlags & ANIM_FLAG_STOP
 					  || gAssetStorage->hasLocalAsset(anim_id, LLAssetType::AT_ANIMATION)))
@@ -1038,10 +1038,9 @@ void LLGestureMgr::runStep(LLMultiGesture* gesture, LLGestureStep* step)
 
 
 // static
-void LLGestureMgr::onLoadComplete(LLVFS *vfs,
-									   const LLUUID& asset_uuid,
-									   LLAssetType::EType type,
-									   void* user_data, S32 status, LLExtStat ext_status)
+void LLGestureMgr::onLoadComplete(const LLUUID& asset_uuid,
+								  LLAssetType::EType type,
+								  void* user_data, S32 status, LLExtStat ext_status)
 {
 	LLLoadInfo* info = (LLLoadInfo*)user_data;
 
@@ -1056,7 +1055,7 @@ void LLGestureMgr::onLoadComplete(LLVFS *vfs,
 
 	if (0 == status)
 	{
-		LLVFile file(vfs, asset_uuid, type, LLVFile::READ);
+		LLFileSystem file(asset_uuid, type, LLFileSystem::READ);
 		S32 size = file.getSize();
 
 		std::vector<char> buffer(size+1);
@@ -1159,8 +1158,7 @@ void LLGestureMgr::onLoadComplete(LLVFS *vfs,
 }
 
 // static
-void LLGestureMgr::onAssetLoadComplete(LLVFS *vfs,
-									   const LLUUID& asset_uuid,
+void LLGestureMgr::onAssetLoadComplete(const LLUUID& asset_uuid,
 									   LLAssetType::EType type,
 									   void* user_data, S32 status, LLExtStat ext_status)
 {
@@ -1172,7 +1170,7 @@ void LLGestureMgr::onAssetLoadComplete(LLVFS *vfs,
 	{
 	case LLAssetType::AT_ANIMATION:
 		{
-			LLKeyframeMotion::onLoadComplete(vfs, asset_uuid, type, user_data, status, ext_status);
+			LLKeyframeMotion::onLoadComplete(asset_uuid, type, user_data, status, ext_status);
 
 			self.mLoadingAssets.erase(asset_uuid);
 
@@ -1180,7 +1178,7 @@ void LLGestureMgr::onAssetLoadComplete(LLVFS *vfs,
 		}
 	case LLAssetType::AT_SOUND:
 		{
-			LLAudioEngine::assetCallback(vfs, asset_uuid, type, user_data, status, ext_status);
+			LLAudioEngine::assetCallback(asset_uuid, type, user_data, status, ext_status);
 
 			self.mLoadingAssets.erase(asset_uuid);
 
diff --git a/indra/newview/llgesturemgr.h b/indra/newview/llgesturemgr.h
index 402bdf6039..91ab445273 100644
--- a/indra/newview/llgesturemgr.h
+++ b/indra/newview/llgesturemgr.h
@@ -40,7 +40,6 @@ class LLMultiGesture;
 class LLGestureListener;
 class LLGestureStep;
 class LLUUID;
-class LLVFS;
 
 class LLGestureManagerObserver
 {
@@ -154,15 +153,13 @@ protected:
 	void done();
 
 	// Used by loadGesture
-	static void onLoadComplete(LLVFS *vfs,
-						   const LLUUID& asset_uuid,
-						   LLAssetType::EType type,
-						   void* user_data, S32 status, LLExtStat ext_status);
+	static void onLoadComplete(const LLUUID& asset_uuid,
+					           LLAssetType::EType type,
+						       void* user_data, S32 status, LLExtStat ext_status);
 
 	// Used by playGesture to load an asset file
 	// required to play a gesture step
-	static void onAssetLoadComplete(LLVFS *vfs,
-									const LLUUID& asset_uuid,
+	static void onAssetLoadComplete(const LLUUID& asset_uuid,
 									LLAssetType::EType type,
 									void* user_data, S32 status, LLExtStat ext_status);
 
diff --git a/indra/newview/lllandmarklist.cpp b/indra/newview/lllandmarklist.cpp
index 9106d4e986..31e76267e6 100644
--- a/indra/newview/lllandmarklist.cpp
+++ b/indra/newview/lllandmarklist.cpp
@@ -33,7 +33,7 @@
 
 #include "llappviewer.h"
 #include "llagent.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
 #include "llviewerstats.h"
 
 // Globals
@@ -124,7 +124,6 @@ LLLandmark* LLLandmarkList::getAsset(const LLUUID& asset_uuid, loaded_callback_t
 
 // static
 void LLLandmarkList::processGetAssetReply(
-	LLVFS *vfs,
 	const LLUUID& uuid,
 	LLAssetType::EType type,
 	void* user_data,
@@ -133,7 +132,7 @@ void LLLandmarkList::processGetAssetReply(
 {
 	if( status == 0 )
 	{
-		LLVFile file(vfs, uuid, type);
+		LLFileSystem file(uuid, type);
 		S32 file_length = file.getSize();
 
         if (file_length > 0)
diff --git a/indra/newview/lllandmarklist.h b/indra/newview/lllandmarklist.h
index 4f3b11660d..f5fa958204 100644
--- a/indra/newview/lllandmarklist.h
+++ b/indra/newview/lllandmarklist.h
@@ -52,7 +52,6 @@ public:
 	BOOL assetExists(const LLUUID& asset_uuid);
 	LLLandmark* getAsset(const LLUUID& asset_uuid, loaded_callback_t cb = NULL);
 	static void processGetAssetReply(
-		LLVFS *vfs,
 		const LLUUID& uuid,
 		LLAssetType::EType type,
 		void* user_data,
diff --git a/indra/newview/llmeshrepository.cpp b/indra/newview/llmeshrepository.cpp
index 2c1c1191da..8080e43383 100644
--- a/indra/newview/llmeshrepository.cpp
+++ b/indra/newview/llmeshrepository.cpp
@@ -49,7 +49,7 @@
 #include "llsdutil_math.h"
 #include "llsdserialize.h"
 #include "llthread.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
 #include "llviewercontrol.h"
 #include "llviewerinventory.h"
 #include "llviewermenufile.h"
@@ -294,8 +294,6 @@
 //   * Header parse failures come without much explanation.  Elaborate.
 //   * Work queue for uploads?  Any need for this or is the current scheme good
 //     enough?
-//   * Various temp buffers used in VFS I/O might be allocated once or even
-//     statically.  Look for some wins here.
 //   * Move data structures holding mesh data used by main thread into main-
 //     thread-only access so that no locking is needed.  May require duplication
 //     of some data so that worker thread has a minimal data set to guide
@@ -1336,8 +1334,8 @@ bool LLMeshRepoThread::fetchMeshSkinInfo(const LLUUID& mesh_id)
 
 		if (version <= MAX_MESH_VERSION && offset >= 0 && size > 0)
 		{
-			//check VFS for mesh skin info
-			LLVFile file(gVFS, mesh_id, LLAssetType::AT_MESH);
+			//check cache for mesh skin info
+			LLFileSystem file(mesh_id, LLAssetType::AT_MESH);
 			if (file.getSize() >= offset+size)
 			{
 				U8* buffer = new(std::nothrow) U8[size];
@@ -1370,7 +1368,7 @@ bool LLMeshRepoThread::fetchMeshSkinInfo(const LLUUID& mesh_id)
 				delete[] buffer;
 			}
 
-			//reading from VFS failed for whatever reason, fetch from sim
+			//reading from cache failed for whatever reason, fetch from sim
 			std::string http_url;
 			constructUrl(mesh_id, &http_url);
 
@@ -1432,8 +1430,8 @@ bool LLMeshRepoThread::fetchMeshDecomposition(const LLUUID& mesh_id)
 
 		if (version <= MAX_MESH_VERSION && offset >= 0 && size > 0)
 		{
-			//check VFS for mesh skin info
-			LLVFile file(gVFS, mesh_id, LLAssetType::AT_MESH);
+			//check cache for mesh skin info
+			LLFileSystem file(mesh_id, LLAssetType::AT_MESH);
 			if (file.getSize() >= offset+size)
 			{
 				U8* buffer = new(std::nothrow) U8[size];
@@ -1467,7 +1465,7 @@ bool LLMeshRepoThread::fetchMeshDecomposition(const LLUUID& mesh_id)
 				delete[] buffer;
 			}
 
-			//reading from VFS failed for whatever reason, fetch from sim
+			//reading from cache failed for whatever reason, fetch from sim
 			std::string http_url;
 			constructUrl(mesh_id, &http_url);
 			
@@ -1529,8 +1527,8 @@ bool LLMeshRepoThread::fetchMeshPhysicsShape(const LLUUID& mesh_id)
 
 		if (version <= MAX_MESH_VERSION && offset >= 0 && size > 0)
 		{
-			//check VFS for mesh physics shape info
-			LLVFile file(gVFS, mesh_id, LLAssetType::AT_MESH);
+			//check cache for mesh physics shape info
+			LLFileSystem file(mesh_id, LLAssetType::AT_MESH);
 			if (file.getSize() >= offset+size)
 			{
 				LLMeshRepository::sCacheBytesRead += size;
@@ -1563,7 +1561,7 @@ bool LLMeshRepoThread::fetchMeshPhysicsShape(const LLUUID& mesh_id)
 				delete[] buffer;
 			}
 
-			//reading from VFS failed for whatever reason, fetch from sim
+			//reading from cache failed for whatever reason, fetch from sim
 			std::string http_url;
 			constructUrl(mesh_id, &http_url);
 			
@@ -1634,8 +1632,8 @@ bool LLMeshRepoThread::fetchMeshHeader(const LLVolumeParams& mesh_params, bool c
 	++LLMeshRepository::sMeshRequestCount;
 
 	{
-		//look for mesh in asset in vfs
-		LLVFile file(gVFS, mesh_params.getSculptID(), LLAssetType::AT_MESH);
+		//look for mesh in asset in cache
+		LLFileSystem file(mesh_params.getSculptID(), LLAssetType::AT_MESH);
 			
 		S32 size = file.getSize();
 
@@ -1649,7 +1647,11 @@ bool LLMeshRepoThread::fetchMeshHeader(const LLVolumeParams& mesh_params, bool c
 			file.read(buffer, bytes);
 			if (headerReceived(mesh_params, buffer, bytes) == MESH_OK)
 			{
-				// Found mesh in VFS cache
+				std::string mid;
+				mesh_params.getSculptID().toString(mid);
+				LL_DEBUGS(LOG_MESH) << "Mesh/Cache: Mesh header for ID " << mid << " - was retrieved from the cache." << LL_ENDL;
+
+				// Found mesh in cache
 				return true;
 			}
 		}
@@ -1660,8 +1662,13 @@ bool LLMeshRepoThread::fetchMeshHeader(const LLVolumeParams& mesh_params, bool c
 	std::string http_url;
 	constructUrl(mesh_params.getSculptID(), &http_url);
 	
+
 	if (!http_url.empty())
 	{
+		std::string mid;
+		mesh_params.getSculptID().toString(mid);
+		LL_DEBUGS(LOG_MESH) << "Mesh/Cache: Mesh header for ID " << mid << " - was retrieved from the simulator." << LL_ENDL;
+
 		//grab first 4KB if we're going to bother with a fetch.  Cache will prevent future fetches if a full mesh fits
 		//within the first 4KB
 		//NOTE -- this will break of headers ever exceed 4KB		
@@ -1713,8 +1720,8 @@ bool LLMeshRepoThread::fetchMeshLOD(const LLVolumeParams& mesh_params, S32 lod,
 		if (version <= MAX_MESH_VERSION && offset >= 0 && size > 0)
 		{
 
-			//check VFS for mesh asset
-			LLVFile file(gVFS, mesh_id, LLAssetType::AT_MESH);
+			//check cache for mesh asset
+			LLFileSystem file(mesh_id, LLAssetType::AT_MESH);
 			if (file.getSize() >= offset+size)
 			{
 				U8* buffer = new(std::nothrow) U8[size];
@@ -1742,6 +1749,11 @@ bool LLMeshRepoThread::fetchMeshLOD(const LLVolumeParams& mesh_params, S32 lod,
 					if (lodReceived(mesh_params, lod, buffer, size) == MESH_OK)
 					{
 						delete[] buffer;
+
+						std::string mid;
+						mesh_id.toString(mid);
+						LL_DEBUGS(LOG_MESH) << "Mesh/Cache: Mesh body for ID " << mid << " - was retrieved from the cache." << LL_ENDL;
+
 						return true;
 					}
 				}
@@ -1749,12 +1761,16 @@ bool LLMeshRepoThread::fetchMeshLOD(const LLVolumeParams& mesh_params, S32 lod,
 				delete[] buffer;
 			}
 
-			//reading from VFS failed for whatever reason, fetch from sim
+			//reading from cache failed for whatever reason, fetch from sim
 			std::string http_url;
 			constructUrl(mesh_id, &http_url);
-			
+
 			if (!http_url.empty())
 			{
+				std::string mid;
+				mesh_id.toString(mid);
+				LL_DEBUGS(LOG_MESH) << "Mesh/Cache: Mesh body for ID " << mid << " - was retrieved from the simulator." << LL_ENDL;
+
                 LLMeshHandlerBase::ptr_t handler(new LLMeshLODHandler(mesh_params, lod, offset, size));
 				LLCore::HttpHandle handle = getByteRange(http_url, offset, size, handler);
 				if (LLCORE_HTTP_HANDLE_INVALID == handle)
@@ -3208,7 +3224,7 @@ void LLMeshHeaderHandler::processData(LLCore::BufferArray * /* body */, S32 /* b
 	}
 	else if (data && data_size > 0)
 	{
-		// header was successfully retrieved from sim and parsed, cache in vfs
+		// header was successfully retrieved from sim and parsed and is in cache
 		S32 header_bytes = 0;
 		LLSD header;
 
@@ -3247,31 +3263,32 @@ void LLMeshHeaderHandler::processData(LLCore::BufferArray * /* body */, S32 /* b
 
 		
 			// It's possible for the remote asset to have more data than is needed for the local cache
-			// only allocate as much space in the VFS as is needed for the local cache
+			// only allocate as much space in the cache as is needed for the local cache
 			data_size = llmin(data_size, bytes);
 
-			LLVFile file(gVFS, mesh_id, LLAssetType::AT_MESH, LLVFile::WRITE);
-			if (file.getMaxSize() >= bytes || file.setMaxSize(bytes))
+			// <FS:Ansariel> Fix asset caching
+			//LLFileSystem file(mesh_id, LLAssetType::AT_MESH, LLFileSystem::WRITE);
+			LLFileSystem file(mesh_id, LLAssetType::AT_MESH, LLFileSystem::READ_WRITE);
+			if (file.getMaxSize() >= bytes)
 			{
 				LLMeshRepository::sCacheBytesWritten += data_size;
 				++LLMeshRepository::sCacheWrites;
 
 				file.write(data, data_size);
-			
-				// zero out the rest of the file 
-				U8 block[MESH_HEADER_SIZE];
-				memset(block, 0, sizeof(block));
 
-				while (bytes-file.tell() > sizeof(block))
-				{
-					file.write(block, sizeof(block));
-				}
-
-				S32 remaining = bytes-file.tell();
+				// <FS:Ansariel> Fix asset caching
+				S32 remaining = bytes - file.tell();
 				if (remaining > 0)
 				{
-					file.write(block, remaining);
+					U8* block = new(std::nothrow) U8[remaining];
+					if (block)
+					{
+						memset(block, 0, remaining);
+						file.write(block, remaining);
+						delete[] block;
+					}
 				}
+				// </FS:Ansariel>
 			}
 		}
 		else
@@ -3323,8 +3340,10 @@ void LLMeshLODHandler::processData(LLCore::BufferArray * /* body */, S32 /* body
 		EMeshProcessingResult result = gMeshRepo.mThread->lodReceived(mMeshParams, mLOD, data, data_size);
 		if (result == MESH_OK)
 		{
-			// good fetch from sim, write to VFS for caching
-			LLVFile file(gVFS, mMeshParams.getSculptID(), LLAssetType::AT_MESH, LLVFile::WRITE);
+			// good fetch from sim, write to cache
+			// <FS:Ansariel> Fix asset caching
+			//LLFileSystem file(mMeshParams.getSculptID(), LLAssetType::AT_MESH, LLFileSystem::WRITE);
+			LLFileSystem file(mMeshParams.getSculptID(), LLAssetType::AT_MESH, LLFileSystem::READ_WRITE);
 
 			S32 offset = mOffset;
 			S32 size = mRequestedBytes;
@@ -3387,8 +3406,10 @@ void LLMeshSkinInfoHandler::processData(LLCore::BufferArray * /* body */, S32 /*
 		&& ((data != NULL) == (data_size > 0)) // if we have data but no size or have size but no data, something is wrong
 		&& gMeshRepo.mThread->skinInfoReceived(mMeshID, data, data_size))
 	{
-		// good fetch from sim, write to VFS for caching
-		LLVFile file(gVFS, mMeshID, LLAssetType::AT_MESH, LLVFile::WRITE);
+		// good fetch from sim, write to cache
+		// <FS:Ansariel> Fix asset caching
+		//LLFileSystem file(mMeshID, LLAssetType::AT_MESH, LLFileSystem::WRITE);
+		LLFileSystem file(mMeshID, LLAssetType::AT_MESH, LLFileSystem::READ_WRITE);
 
 		S32 offset = mOffset;
 		S32 size = mRequestedBytes;
@@ -3435,8 +3456,10 @@ void LLMeshDecompositionHandler::processData(LLCore::BufferArray * /* body */, S
 		&& ((data != NULL) == (data_size > 0)) // if we have data but no size or have size but no data, something is wrong
 		&& gMeshRepo.mThread->decompositionReceived(mMeshID, data, data_size))
 	{
-		// good fetch from sim, write to VFS for caching
-		LLVFile file(gVFS, mMeshID, LLAssetType::AT_MESH, LLVFile::WRITE);
+		// good fetch from sim, write to cache
+		// <FS:Ansariel> Fix asset caching
+		//LLFileSystem file(mMeshID, LLAssetType::AT_MESH, LLFileSystem::WRITE);
+		LLFileSystem file(mMeshID, LLAssetType::AT_MESH, LLFileSystem::READ_WRITE);
 
 		S32 offset = mOffset;
 		S32 size = mRequestedBytes;
@@ -3482,8 +3505,10 @@ void LLMeshPhysicsShapeHandler::processData(LLCore::BufferArray * /* body */, S3
 		&& ((data != NULL) == (data_size > 0)) // if we have data but no size or have size but no data, something is wrong
 		&& gMeshRepo.mThread->physicsShapeReceived(mMeshID, data, data_size) == MESH_OK)
 	{
-		// good fetch from sim, write to VFS for caching
-		LLVFile file(gVFS, mMeshID, LLAssetType::AT_MESH, LLVFile::WRITE);
+		// good fetch from sim, write to cache for caching
+		// <FS:Ansariel> Fix asset caching
+		//LLFileSystem file(mMeshID, LLAssetType::AT_MESH, LLFileSystem::WRITE);
+		LLFileSystem file(mMeshID, LLAssetType::AT_MESH, LLFileSystem::READ_WRITE);
 
 		S32 offset = mOffset;
 		S32 size = mRequestedBytes;
diff --git a/indra/newview/llmeshrepository.h b/indra/newview/llmeshrepository.h
index 81e49cb1d8..441264d42f 100644
--- a/indra/newview/llmeshrepository.h
+++ b/indra/newview/llmeshrepository.h
@@ -48,7 +48,6 @@
 class LLVOVolume;
 class LLMutex;
 class LLCondition;
-class LLVFS;
 class LLMeshRepository;
 
 typedef enum e_mesh_processing_result_enum
diff --git a/indra/newview/lloutfitgallery.cpp b/indra/newview/lloutfitgallery.cpp
index 718b67dbde..4febb72c6c 100644
--- a/indra/newview/lloutfitgallery.cpp
+++ b/indra/newview/lloutfitgallery.cpp
@@ -32,7 +32,7 @@
 
 // llcommon
 #include "llcommonutils.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
 
 #include "llaccordionctrltab.h"
 #include "llappearancemgr.h"
diff --git a/indra/newview/lloutfitgallery.h b/indra/newview/lloutfitgallery.h
index 6dd8a6298f..ce5c090134 100644
--- a/indra/newview/lloutfitgallery.h
+++ b/indra/newview/lloutfitgallery.h
@@ -38,7 +38,6 @@
 
 #include <vector>
 
-class LLVFS;
 class LLOutfitGallery;
 class LLOutfitGalleryItem;
 class LLOutfitListGearMenuBase;
diff --git a/indra/newview/llpostcard.cpp b/indra/newview/llpostcard.cpp
index d5775042c1..071fc31d27 100644
--- a/indra/newview/llpostcard.cpp
+++ b/indra/newview/llpostcard.cpp
@@ -28,8 +28,7 @@
 
 #include "llpostcard.h"
 
-#include "llvfile.h"
-#include "llvfs.h"
+#include "llfilesystem.h"
 #include "llviewerregion.h"
 
 #include "message.h"
diff --git a/indra/newview/llpreviewgesture.cpp b/indra/newview/llpreviewgesture.cpp
index 18c2fb5452..061ecad099 100644
--- a/indra/newview/llpreviewgesture.cpp
+++ b/indra/newview/llpreviewgesture.cpp
@@ -30,7 +30,7 @@
 #include "llagent.h"
 #include "llanimstatelabels.h"
 #include "llanimationstates.h"
-#include "llappviewer.h"			// gVFS
+#include "llappviewer.h"
 #include "llcheckboxctrl.h"
 #include "llcombobox.h"
 #include "lldatapacker.h"
@@ -47,7 +47,7 @@
 #include "llradiogroup.h"
 #include "llresmgr.h"
 #include "lltrans.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
 #include "llviewerobjectlist.h"
 #include "llviewerregion.h"
 #include "llviewerstats.h"
@@ -841,10 +841,9 @@ void LLPreviewGesture::loadAsset()
 
 
 // static
-void LLPreviewGesture::onLoadComplete(LLVFS *vfs,
-									   const LLUUID& asset_uuid,
-									   LLAssetType::EType type,
-									   void* user_data, S32 status, LLExtStat ext_status)
+void LLPreviewGesture::onLoadComplete(const LLUUID& asset_uuid,
+									  LLAssetType::EType type,
+									  void* user_data, S32 status, LLExtStat ext_status)
 {
 	LLUUID* item_idp = (LLUUID*)user_data;
 
@@ -853,7 +852,7 @@ void LLPreviewGesture::onLoadComplete(LLVFS *vfs,
 	{
 		if (0 == status)
 		{
-			LLVFile file(vfs, asset_uuid, type, LLVFile::READ);
+			LLFileSystem file(asset_uuid, type, LLFileSystem::READ);
 			S32 size = file.getSize();
 
 			std::vector<char> buffer(size+1);
@@ -1142,10 +1141,9 @@ void LLPreviewGesture::saveIfNeeded()
             tid.generate();
             assetId = tid.makeAssetID(gAgent.getSecureSessionID());
 
-            LLVFile file(gVFS, assetId, LLAssetType::AT_GESTURE, LLVFile::APPEND);
+            LLFileSystem file(assetId, LLAssetType::AT_GESTURE, LLFileSystem::APPEND);
 
             S32 size = dp.getCurrentSize();
-            file.setMaxSize(size);
             file.write((U8*)buffer, size);
 
             LLLineEditor* descEditor = getChild<LLLineEditor>("desc");
diff --git a/indra/newview/llpreviewgesture.h b/indra/newview/llpreviewgesture.h
index ffcada4cc2..f5c47d71b8 100644
--- a/indra/newview/llpreviewgesture.h
+++ b/indra/newview/llpreviewgesture.h
@@ -39,7 +39,6 @@ class LLScrollListCtrl;
 class LLScrollListItem;
 class LLButton;
 class LLRadioGroup;
-class LLVFS;
 
 class LLPreviewGesture : public LLPreview
 {
@@ -80,8 +79,7 @@ protected:
 
 	void loadAsset();
 
-	static void onLoadComplete(LLVFS *vfs,
-							   const LLUUID& asset_uuid,
+	static void onLoadComplete(const LLUUID& asset_uuid,
 							   LLAssetType::EType type,
 							   void* user_data, S32 status, LLExtStat ext_status);
 
diff --git a/indra/newview/llpreviewnotecard.cpp b/indra/newview/llpreviewnotecard.cpp
index 59be35fe92..230def5362 100644
--- a/indra/newview/llpreviewnotecard.cpp
+++ b/indra/newview/llpreviewnotecard.cpp
@@ -46,7 +46,7 @@
 #include "llselectmgr.h"
 #include "lltrans.h"
 #include "llviewertexteditor.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
 #include "llviewerinventory.h"
 #include "llviewerobject.h"
 #include "llviewerobjectlist.h"
@@ -352,8 +352,7 @@ void LLPreviewNotecard::loadAsset()
 }
 
 // static
-void LLPreviewNotecard::onLoadComplete(LLVFS *vfs,
-									   const LLUUID& asset_uuid,
+void LLPreviewNotecard::onLoadComplete(const LLUUID& asset_uuid,
 									   LLAssetType::EType type,
 									   void* user_data, S32 status, LLExtStat ext_status)
 {
@@ -364,7 +363,7 @@ void LLPreviewNotecard::onLoadComplete(LLVFS *vfs,
 	{
 		if(0 == status)
 		{
-			LLVFile file(vfs, asset_uuid, type, LLVFile::READ);
+			LLFileSystem file(asset_uuid, type, LLFileSystem::READ);
 
 			S32 file_length = file.getSize();
 
@@ -471,7 +470,7 @@ void LLPreviewNotecard::finishInventoryUpload(LLUUID itemId, LLUUID newAssetId,
     LLPreviewNotecard* nc = LLFloaterReg::findTypedInstance<LLPreviewNotecard>("preview_notecard", LLSD(itemId));
     if (nc)
     {
-        // *HACK: we have to delete the asset in the VFS so
+        // *HACK: we have to delete the asset in the cache so
         // that the viewer will redownload it. This is only
         // really necessary if the asset had to be modified by
         // the uploader, so this can be optimized away in some
@@ -479,7 +478,7 @@ void LLPreviewNotecard::finishInventoryUpload(LLUUID itemId, LLUUID newAssetId,
         // script actually changed the asset.
         if (nc->hasEmbeddedInventory())
         {
-            gVFS->removeFile(newAssetId, LLAssetType::AT_NOTECARD);
+            LLFileSystem::removeFile(newAssetId, LLAssetType::AT_NOTECARD);
         }
         if (newItemId.isNull())
         {
@@ -504,7 +503,7 @@ void LLPreviewNotecard::finishTaskUpload(LLUUID itemId, LLUUID newAssetId, LLUUI
     {
         if (nc->hasEmbeddedInventory())
         {
-            gVFS->removeFile(newAssetId, LLAssetType::AT_NOTECARD);
+            LLFileSystem::removeFile(newAssetId, LLAssetType::AT_NOTECARD);
         }
         nc->setAssetId(newAssetId);
         nc->refreshFromInventory();
@@ -583,14 +582,13 @@ bool LLPreviewNotecard::saveIfNeeded(LLInventoryItem* copyitem, bool sync)
                 tid.generate();
                 asset_id = tid.makeAssetID(gAgent.getSecureSessionID());
 
-                LLVFile file(gVFS, asset_id, LLAssetType::AT_NOTECARD, LLVFile::APPEND);
+                LLFileSystem file(asset_id, LLAssetType::AT_NOTECARD, LLFileSystem::APPEND);
 
 
 				LLSaveNotecardInfo* info = new LLSaveNotecardInfo(this, mItemUUID, mObjectUUID,
 																tid, copyitem);
 
                 S32 size = buffer.length() + 1;
-                file.setMaxSize(size);
                 file.write((U8*)buffer.c_str(), size);
 
 				gAssetStorage->storeAssetData(tid, LLAssetType::AT_NOTECARD,
diff --git a/indra/newview/llpreviewnotecard.h b/indra/newview/llpreviewnotecard.h
index 3a706b8645..321f44a1ea 100644
--- a/indra/newview/llpreviewnotecard.h
+++ b/indra/newview/llpreviewnotecard.h
@@ -89,8 +89,7 @@ protected:
 
 	void deleteNotecard();
 
-	static void onLoadComplete(LLVFS *vfs,
-							   const LLUUID& asset_uuid,
+	static void onLoadComplete(const LLUUID& asset_uuid,
 							   LLAssetType::EType type,
 							   void* user_data, S32 status, LLExtStat ext_status);
 
diff --git a/indra/newview/llpreviewscript.cpp b/indra/newview/llpreviewscript.cpp
index f13910cde5..a32dc8beda 100644
--- a/indra/newview/llpreviewscript.cpp
+++ b/indra/newview/llpreviewscript.cpp
@@ -51,7 +51,7 @@
 #include "llsdserialize.h"
 #include "llslider.h"
 #include "lltooldraganddrop.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
 
 #include "llagent.h"
 #include "llmenugl.h"
@@ -1714,8 +1714,11 @@ void LLPreviewLSL::saveIfNeeded(bool sync /*= true*/)
         {
             std::string buffer(mScriptEd->mEditor->getText());
 
+            LLUUID old_asset_id = inv_item->getAssetUUID().isNull() ? mScriptEd->getAssetID() : inv_item->getAssetUUID();
+
             LLResourceUploadInfo::ptr_t uploadInfo(std::make_shared<LLScriptAssetUpload>(mItemUUID, buffer, 
-                [](LLUUID itemId, LLUUID, LLUUID, LLSD response) {
+                [old_asset_id](LLUUID itemId, LLUUID, LLUUID, LLSD response) {
+                    LLFileSystem::removeFile(old_asset_id, LLAssetType::AT_LSL_TEXT);
                     LLPreviewLSL::finishedLSLUpload(itemId, response);
                 }));
 
@@ -1725,8 +1728,8 @@ void LLPreviewLSL::saveIfNeeded(bool sync /*= true*/)
 }
 
 // static
-void LLPreviewLSL::onLoadComplete( LLVFS *vfs, const LLUUID& asset_uuid, LLAssetType::EType type,
-								   void* user_data, S32 status, LLExtStat ext_status)
+void LLPreviewLSL::onLoadComplete(const LLUUID& asset_uuid, LLAssetType::EType type,
+								  void* user_data, S32 status, LLExtStat ext_status)
 {
 	LL_DEBUGS() << "LLPreviewLSL::onLoadComplete: got uuid " << asset_uuid
 		 << LL_ENDL;
@@ -1736,7 +1739,7 @@ void LLPreviewLSL::onLoadComplete( LLVFS *vfs, const LLUUID& asset_uuid, LLAsset
 	{
 		if(0 == status)
 		{
-			LLVFile file(vfs, asset_uuid, type);
+			LLFileSystem file(asset_uuid, type);
 			S32 file_length = file.getSize();
 
 			std::vector<char> buffer(file_length+1);
@@ -1763,6 +1766,7 @@ void LLPreviewLSL::onLoadComplete( LLVFS *vfs, const LLUUID& asset_uuid, LLAsset
 			}
 			preview->mScriptEd->setScriptName(script_name);
 			preview->mScriptEd->setEnableEditing(is_modifiable);
+            preview->mScriptEd->setAssetID(asset_uuid);
 			preview->mAssetStatus = PREVIEW_ASSET_LOADED;
 		}
 		else
@@ -1999,7 +2003,7 @@ void LLLiveLSLEditor::loadAsset()
 }
 
 // static
-void LLLiveLSLEditor::onLoadComplete(LLVFS *vfs, const LLUUID& asset_id,
+void LLLiveLSLEditor::onLoadComplete(const LLUUID& asset_id,
 									 LLAssetType::EType type,
 									 void* user_data, S32 status, LLExtStat ext_status)
 {
@@ -2013,9 +2017,10 @@ void LLLiveLSLEditor::onLoadComplete(LLVFS *vfs, const LLUUID& asset_id,
 	{
 		if( LL_ERR_NOERR == status )
 		{
-			instance->loadScriptText(vfs, asset_id, type);
+			instance->loadScriptText(asset_id, type);
 			instance->mScriptEd->setEnableEditing(TRUE);
 			instance->mAssetStatus = PREVIEW_ASSET_LOADED;
+            instance->mScriptEd->setAssetID(asset_id);
 		}
 		else
 		{
@@ -2039,9 +2044,9 @@ void LLLiveLSLEditor::onLoadComplete(LLVFS *vfs, const LLUUID& asset_id,
 	delete floater_key;
 }
 
-void LLLiveLSLEditor::loadScriptText(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type)
+void LLLiveLSLEditor::loadScriptText(const LLUUID &uuid, LLAssetType::EType type)
 {
-	LLVFile file(vfs, uuid, type);
+	LLFileSystem file(uuid, type);
 	S32 file_length = file.getSize();
 	std::vector<char> buffer(file_length + 1);
 	file.read((U8*)&buffer[0], file_length);
@@ -2195,6 +2200,7 @@ void LLLiveLSLEditor::finishLSLUpload(LLUUID itemId, LLUUID taskId, LLUUID newAs
     if (preview)
     {
         preview->mItem->setAssetUUID(newAssetId);
+        preview->mScriptEd->setAssetID(newAssetId);
 
         // Bytecode save completed
         if (response["compiled"])
@@ -2265,12 +2271,14 @@ void LLLiveLSLEditor::saveIfNeeded(bool sync /*= true*/)
     if (!url.empty())
     {
         std::string buffer(mScriptEd->mEditor->getText());
+        LLUUID old_asset_id = mScriptEd->getAssetID();
 
         LLResourceUploadInfo::ptr_t uploadInfo(std::make_shared<LLScriptAssetUpload>(mObjectUUID, mItemUUID, 
                 monoChecked() ? LLScriptAssetUpload::MONO : LLScriptAssetUpload::LSL2, 
                 isRunning, mScriptEd->getAssociatedExperience(), buffer, 
-                [isRunning](LLUUID itemId, LLUUID taskId, LLUUID newAssetId, LLSD response) { 
-                    LLLiveLSLEditor::finishLSLUpload(itemId, taskId, newAssetId, response, isRunning);
+                [isRunning, old_asset_id](LLUUID itemId, LLUUID taskId, LLUUID newAssetId, LLSD response) { 
+                        LLFileSystem::removeFile(old_asset_id, LLAssetType::AT_LSL_TEXT);
+                        LLLiveLSLEditor::finishLSLUpload(itemId, taskId, newAssetId, response, isRunning);
                 }));
 
         LLViewerAssetUpload::EnqueueInventoryUpload(url, uploadInfo);
diff --git a/indra/newview/llpreviewscript.h b/indra/newview/llpreviewscript.h
index c1fea31063..f851ff6f3f 100644
--- a/indra/newview/llpreviewscript.h
+++ b/indra/newview/llpreviewscript.h
@@ -48,7 +48,6 @@ struct 	LLEntryAndEdCore;
 class LLMenuBarGL;
 class LLFloaterScriptSearch;
 class LLKeywordToken;
-class LLVFS;
 class LLViewerInventoryItem;
 class LLScriptEdContainer;
 class LLFloaterGotoLine;
@@ -143,6 +142,9 @@ public:
 
 	void 			setItemRemoved(bool script_removed){mScriptRemoved = script_removed;};
 
+    void 			setAssetID( const LLUUID& asset_id){ mAssetID = asset_id; };
+    LLUUID 			getAssetID() { return mAssetID; }
+
 private:
 	void		onBtnDynamicHelp();
 	void		onBtnUndoChanges();
@@ -188,6 +190,7 @@ private:
 	LLUUID			mAssociatedExperience;
 	BOOL			mScriptRemoved;
 	BOOL			mSaveDialogShown;
+    LLUUID          mAssetID;
 
 	LLScriptEdContainer* mContainer; // parent view
 
@@ -234,7 +237,7 @@ protected:
 	static void onLoad(void* userdata);
 	static void onSave(void* userdata, BOOL close_after_save);
 	
-	static void onLoadComplete(LLVFS *vfs, const LLUUID& uuid,
+	static void onLoadComplete(const LLUUID& uuid,
 							   LLAssetType::EType type,
 							   void* user_data, S32 status, LLExtStat ext_status);
 
@@ -295,13 +298,13 @@ private:
 	static void onLoad(void* userdata);
 	static void onSave(void* userdata, BOOL close_after_save);
 
-	static void onLoadComplete(LLVFS *vfs, const LLUUID& asset_uuid,
+	static void onLoadComplete(const LLUUID& asset_uuid,
 							   LLAssetType::EType type,
 							   void* user_data, S32 status, LLExtStat ext_status);
 	static void onRunningCheckboxClicked(LLUICtrl*, void* userdata);
 	static void onReset(void* userdata);
 
-	void loadScriptText(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type);
+	void loadScriptText(const LLUUID &uuid, LLAssetType::EType type);
 
 	static void onErrorList(LLUICtrl*, void* user_data);
 
diff --git a/indra/newview/llsettingsvo.cpp b/indra/newview/llsettingsvo.cpp
index 1e5b893cbc..58cbe0e20a 100644
--- a/indra/newview/llsettingsvo.cpp
+++ b/indra/newview/llsettingsvo.cpp
@@ -57,7 +57,7 @@
 
 #include "llinventorymodel.h"
 #include "llassetstorage.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
 #include "lldrawpoolwater.h"
 
 #include <boost/algorithm/string/replace.hpp>
@@ -292,18 +292,18 @@ void LLSettingsVOBase::onTaskAssetUploadComplete(LLUUID itemId, LLUUID taskId, L
 void LLSettingsVOBase::getSettingsAsset(const LLUUID &assetId, LLSettingsVOBase::asset_download_fn callback)
 {
     gAssetStorage->getAssetData(assetId, LLAssetType::AT_SETTINGS,
-        [callback](LLVFS *vfs, const LLUUID &asset_id, LLAssetType::EType, void *, S32 status, LLExtStat ext_status) 
-            { onAssetDownloadComplete(vfs, asset_id, status, ext_status, callback); },
+        [callback](const LLUUID &asset_id, LLAssetType::EType, void *, S32 status, LLExtStat ext_status) 
+            { onAssetDownloadComplete(asset_id, status, ext_status, callback); },
         nullptr, true);
 
 }
 
-void LLSettingsVOBase::onAssetDownloadComplete(LLVFS *vfs, const LLUUID &asset_id, S32 status, LLExtStat ext_status, LLSettingsVOBase::asset_download_fn callback)
+void LLSettingsVOBase::onAssetDownloadComplete(const LLUUID &asset_id, S32 status, LLExtStat ext_status, LLSettingsVOBase::asset_download_fn callback)
 {
     LLSettingsBase::ptr_t settings;
     if (!status)
     {
-        LLVFile file(vfs, asset_id, LLAssetType::AT_SETTINGS, LLVFile::READ);
+        LLFileSystem file(asset_id, LLAssetType::AT_SETTINGS, LLFileSystem::READ);
         S32 size = file.getSize();
 
         std::string buffer(size + 1, '\0');
diff --git a/indra/newview/llsettingsvo.h b/indra/newview/llsettingsvo.h
index 65136ad2f5..a1baf02fe7 100644
--- a/indra/newview/llsettingsvo.h
+++ b/indra/newview/llsettingsvo.h
@@ -38,7 +38,6 @@
 #include "llextendedstatus.h"
 #include <boost/signals2.hpp>
 
-class LLVFS;
 class LLInventoryItem;
 class LLGLSLShader;
 
@@ -81,7 +80,7 @@ private:
     static void     onAgentAssetUploadComplete(LLUUID itemId, LLUUID newAssetId, LLUUID newItemId, LLSD response, LLSettingsBase::ptr_t psettings, inventory_result_fn callback);
     static void     onTaskAssetUploadComplete(LLUUID itemId, LLUUID taskId, LLUUID newAssetId, LLSD response, LLSettingsBase::ptr_t psettings, inventory_result_fn callback);
     
-    static void     onAssetDownloadComplete(LLVFS *vfs, const LLUUID &asset_id, S32 status, LLExtStat ext_status, asset_download_fn callback);
+    static void     onAssetDownloadComplete(const LLUUID &asset_id, S32 status, LLExtStat ext_status, asset_download_fn callback);
 };
 
 //=========================================================================
diff --git a/indra/newview/llsnapshotlivepreview.cpp b/indra/newview/llsnapshotlivepreview.cpp
index 8369def968..8134187c21 100644
--- a/indra/newview/llsnapshotlivepreview.cpp
+++ b/indra/newview/llsnapshotlivepreview.cpp
@@ -31,6 +31,7 @@
 #include "llagentbenefits.h"
 #include "llagentcamera.h"
 #include "llagentui.h"
+#include "llfilesystem.h"
 #include "llcombobox.h"
 #include "llfloaterperms.h"
 #include "llfloaterreg.h"
@@ -50,8 +51,6 @@
 #include "llviewercontrol.h"
 #include "llviewermenufile.h"	// upload_new_resource()
 #include "llviewerstats.h"
-#include "llvfile.h"
-#include "llvfs.h"
 #include "llwindow.h"
 #include "llworld.h"
 #include <boost/filesystem.hpp>
@@ -1006,7 +1005,8 @@ void LLSnapshotLivePreview::saveTexture(BOOL outfit_snapshot, std::string name)
 
 	if (formatted->encode(scaled, 0.0f))
 	{
-		LLVFile::writeFile(formatted->getData(), formatted->getDataSize(), gVFS, new_asset_id, LLAssetType::AT_TEXTURE);
+        LLFileSystem fmt_file(new_asset_id, LLAssetType::AT_TEXTURE, LLFileSystem::WRITE);
+        fmt_file.write(formatted->getData(), formatted->getDataSize());
 		std::string pos_string;
 		LLAgentUI::buildLocationString(pos_string, LLAgentUI::LOCATION_FORMAT_FULL);
 		std::string who_took_it;
diff --git a/indra/newview/llstartup.cpp b/indra/newview/llstartup.cpp
index f22be6481a..54f3e6305c 100644
--- a/indra/newview/llstartup.cpp
+++ b/indra/newview/llstartup.cpp
@@ -82,7 +82,6 @@
 #include "llversioninfo.h"
 #include "llviewercontrol.h"
 #include "llviewerhelp.h"
-#include "llvfs.h"
 #include "llxorcipher.h"	// saved password, MAC address
 #include "llwindow.h"
 #include "message.h"
@@ -271,7 +270,7 @@ bool login_alert_status(const LLSD& notification, const LLSD& response);
 void login_packet_failed(void**, S32 result);
 void use_circuit_callback(void**, S32 result);
 void register_viewer_callbacks(LLMessageSystem* msg);
-void asset_callback_nothing(LLVFS*, const LLUUID&, LLAssetType::EType, void*, S32);
+void asset_callback_nothing(const LLUUID&, LLAssetType::EType, void*, S32);
 bool callback_choose_gender(const LLSD& notification, const LLSD& response);
 void init_start_screen(S32 location_id);
 void release_start_screen();
@@ -585,7 +584,7 @@ bool idle_startup()
 			// start the xfer system. by default, choke the downloads
 			// a lot...
 			const S32 VIEWER_MAX_XFER = 3;
-			start_xfer_manager(gVFS);
+			start_xfer_manager();
 			gXferManager->setMaxIncomingXfers(VIEWER_MAX_XFER);
 			F32 xfer_throttle_bps = gSavedSettings.getF32("XferThrottle");
 			if (xfer_throttle_bps > 1.f)
@@ -593,7 +592,7 @@ bool idle_startup()
 				gXferManager->setUseAckThrottling(TRUE);
 				gXferManager->setAckThrottleBPS(xfer_throttle_bps);
 			}
-			gAssetStorage = new LLViewerAssetStorage(msg, gXferManager, gVFS, gStaticVFS);
+			gAssetStorage = new LLViewerAssetStorage(msg, gXferManager);
 
 
 			F32 dropPercent = gSavedSettings.getF32("PacketDropPercentage");
@@ -1009,13 +1008,6 @@ bool idle_startup()
 
 		gViewerWindow->revealIntroPanel();
 
-		// Poke the VFS, which could potentially block for a while if
-		// Windows XP is acting up
-		set_startup_status(0.07f, LLTrans::getString("LoginVerifyingCache"), LLStringUtil::null);
-		display_startup();
-
-		gVFS->pokeFiles();
-
 		LLStartUp::setStartupState( STATE_LOGIN_AUTH_INIT );
 
 		return FALSE;
@@ -2604,7 +2596,7 @@ void register_viewer_callbacks(LLMessageSystem* msg)
 	msg->setHandlerFuncFast(_PREHASH_FeatureDisabled, process_feature_disabled_message);
 }
 
-void asset_callback_nothing(LLVFS*, const LLUUID&, LLAssetType::EType, void*, S32)
+void asset_callback_nothing(const LLUUID&, LLAssetType::EType, void*, S32)
 {
 	// nothing
 }
diff --git a/indra/newview/lltexturecache.cpp b/indra/newview/lltexturecache.cpp
index a9f19dc32d..d4fc6f3de2 100644
--- a/indra/newview/lltexturecache.cpp
+++ b/indra/newview/lltexturecache.cpp
@@ -55,6 +55,7 @@ const S32 TEXTURE_FAST_CACHE_ENTRY_OVERHEAD = sizeof(S32) * 4; //w, h, c, level
 const S32 TEXTURE_FAST_CACHE_DATA_SIZE = 16 * 16 * 4;
 const S32 TEXTURE_FAST_CACHE_ENTRY_SIZE = TEXTURE_FAST_CACHE_DATA_SIZE + TEXTURE_FAST_CACHE_ENTRY_OVERHEAD;
 const F32 TEXTURE_LAZY_PURGE_TIME_LIMIT = .004f; // 4ms. Would be better to autoadjust, but there is a major cache rework in progress.
+const F32 TEXTURE_PRUNING_MAX_TIME = 15.f;
 
 class LLTextureCacheWorker : public LLWorkerClass
 {
@@ -1551,7 +1552,6 @@ void LLTextureCache::readHeaderCache()
 			if (num_entries - empty_entries > sCacheMaxEntries)
 			{
 				// Special case: cache size was reduced, need to remove entries
-				// Note: After we prune entries, we will call this again and create the LRU
 				U32 entries_to_purge = (num_entries - empty_entries) - sCacheMaxEntries;
 				LL_INFOS() << "Texture Cache Entries: " << num_entries << " Max: " << sCacheMaxEntries << " Empty: " << empty_entries << " Purging: " << entries_to_purge << LL_ENDL;
 				// We can exit the following loop with the given condition, since if we'd reach the end of the lru set we'd have:
@@ -1564,7 +1564,7 @@ void LLTextureCache::readHeaderCache()
 					++iter;
 				}
 			}
-			else
+
 			{
 				S32 lru_entries = (S32)((F32)sCacheMaxEntries * TEXTURE_CACHE_LRU_SIZE);
 				for (std::set<lru_data_t>::iterator iter = lru.begin(); iter != lru.end(); ++iter)
@@ -1578,30 +1578,19 @@ void LLTextureCache::readHeaderCache()
 			
 			if (purge_list.size() > 0)
 			{
+				LLTimer timer;
 				for (std::set<U32>::iterator iter = purge_list.begin(); iter != purge_list.end(); ++iter)
 				{
 					std::string tex_filename = getTextureFileName(entries[*iter].mID);
 					removeEntry((S32)*iter, entries[*iter], tex_filename);
-				}
-				// If we removed any entries, we need to rebuild the entries list,
-				// write the header, and call this again
-				std::vector<Entry> new_entries;
-				for (U32 i=0; i<num_entries; i++)
-				{
-					const Entry& entry = entries[i];
-					if (entry.mImageSize > 0)
+
+					//make sure that pruning entries doesn't take too much time
+					if (timer.getElapsedTimeF32() > TEXTURE_PRUNING_MAX_TIME)
 					{
-						new_entries.push_back(entry);
+						break;
 					}
 				}
-                mFreeList.clear(); // recreating list, no longer valid.
-				llassert_always(new_entries.size() <= sCacheMaxEntries);
-				mHeaderEntriesInfo.mEntries = new_entries.size();
-				writeEntriesHeader();
-				writeEntriesAndClose(new_entries);
-				mHeaderMutex.unlock(); // unlock the mutex before calling again
-				readHeaderCache(); // repeat with new entries file
-				mHeaderMutex.lock();
+				writeEntriesAndClose(entries);
 			}
 			else
 			{
@@ -1724,7 +1713,7 @@ void LLTextureCache::purgeTexturesLazy(F32 time_limit_sec)
 		}
 
 		S64 cache_size = mTexturesSizeTotal;
-		S64 purged_cache_size = (sCacheMaxTexturesSize * (S64)((1.f - TEXTURE_CACHE_PURGE_AMOUNT) * 100)) / 100;
+		S64 purged_cache_size = (llmax(cache_size, sCacheMaxTexturesSize) * (S64)((1.f - TEXTURE_CACHE_PURGE_AMOUNT) * 100)) / 100;
 		for (time_idx_set_t::iterator iter = time_idx_set.begin();
 			iter != time_idx_set.end(); ++iter)
 		{
@@ -1820,21 +1809,26 @@ void LLTextureCache::purgeTextures(bool validate)
 	}
 
 	S64 cache_size = mTexturesSizeTotal;
-	S64 purged_cache_size = (sCacheMaxTexturesSize * (S64)((1.f-TEXTURE_CACHE_PURGE_AMOUNT)*100)) / 100;
+	S64 purged_cache_size = (llmax(cache_size, sCacheMaxTexturesSize) * (S64)((1.f - TEXTURE_CACHE_PURGE_AMOUNT) * 100)) / 100;
 	S32 purge_count = 0;
 	for (time_idx_set_t::iterator iter = time_idx_set.begin();
 		 iter != time_idx_set.end(); ++iter)
 	{
 		S32 idx = iter->second;
 		bool purge_entry = false;		
-        if (validate)
+
+		if (cache_size >= purged_cache_size)
+		{
+			purge_entry = true;
+		}
+		else if (validate)
 		{
 			// make sure file exists and is the correct size
 			U32 uuididx = entries[idx].mID.mData[0];
 			if (uuididx == validate_idx)
 			{
-                std::string filename = getTextureFileName(entries[idx].mID);
- 				LL_DEBUGS("TextureCache") << "Validating: " << filename << "Size: " << entries[idx].mBodySize << LL_ENDL;
+				std::string filename = getTextureFileName(entries[idx].mID);
+				LL_DEBUGS("TextureCache") << "Validating: " << filename << "Size: " << entries[idx].mBodySize << LL_ENDL;
 				// mHeaderAPRFilePoolp because this is under header mutex in main thread
 				S32 bodysize = LLAPRFile::size(filename, mHeaderAPRFilePoolp);
 				if (bodysize != entries[idx].mBodySize)
@@ -1844,10 +1838,6 @@ void LLTextureCache::purgeTextures(bool validate)
 				}
 			}
 		}
-		else if (cache_size >= purged_cache_size)
-		{
-			purge_entry = true;
-		}
 		else
 		{
 			break;
diff --git a/indra/newview/llviewerassetstorage.cpp b/indra/newview/llviewerassetstorage.cpp
index 64d9ce62c5..0f102411d5 100644
--- a/indra/newview/llviewerassetstorage.cpp
+++ b/indra/newview/llviewerassetstorage.cpp
@@ -28,8 +28,7 @@
 
 #include "llviewerassetstorage.h"
 
-#include "llvfile.h"
-#include "llvfs.h"
+#include "llfilesystem.h"
 #include "message.h"
 
 #include "llagent.h"
@@ -104,10 +103,8 @@ public:
 ///----------------------------------------------------------------------------
 
 // Unused?
-LLViewerAssetStorage::LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
-                                           LLVFS *vfs, LLVFS *static_vfs, 
-                                           const LLHost &upstream_host)
-    : LLAssetStorage(msg, xfer, vfs, static_vfs, upstream_host),
+LLViewerAssetStorage::LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *xfer, const LLHost &upstream_host)
+    : LLAssetStorage(msg, xfer, upstream_host),
       mAssetCoroCount(0),
       mCountRequests(0),
       mCountStarted(0),
@@ -118,10 +115,8 @@ LLViewerAssetStorage::LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *
     LLCoprocedureManager::instance().initializePool(VIEWER_ASSET_STORAGE_CORO_POOL);
 }
 
-
-LLViewerAssetStorage::LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
-                                           LLVFS *vfs, LLVFS *static_vfs)
-    : LLAssetStorage(msg, xfer, vfs, static_vfs),
+LLViewerAssetStorage::LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *xfer)
+    : LLAssetStorage(msg, xfer),
       mAssetCoroCount(0),
       mCountRequests(0),
       mCountStarted(0),
@@ -167,13 +162,13 @@ void LLViewerAssetStorage::storeAssetData(
     
     if (mUpstreamHost.isOk())
     {
-        if (mVFS->getExists(asset_id, asset_type))
+        if (LLFileSystem::getExists(asset_id, asset_type))
         {
             // Pack data into this packet if we can fit it.
             U8 buffer[MTUBYTES];
             buffer[0] = 0;
 
-            LLVFile vfile(mVFS, asset_id, asset_type, LLVFile::READ);
+            LLFileSystem vfile(asset_id, asset_type, LLFileSystem::READ);
             S32 asset_size = vfile.getSize();
 
             LLAssetRequest *req = new LLAssetRequest(asset_id, asset_type);
@@ -182,22 +177,20 @@ void LLViewerAssetStorage::storeAssetData(
 
             if (asset_size < 1)
             {
-                // This can happen if there's a bug in our code or if the VFS has been corrupted.
-                LL_WARNS("AssetStorage") << "LLViewerAssetStorage::storeAssetData()  Data _should_ already be in the VFS, but it's not! " << asset_id << LL_ENDL;
-                // LLAssetStorage metric: Zero size VFS
-                reportMetric( asset_id, asset_type, LLStringUtil::null, LLUUID::null, 0, MR_ZERO_SIZE, __FILE__, __LINE__, "The file didn't exist or was zero length (VFS - can't tell which)" );
+                // This can happen if there's a bug in our code or if the cache has been corrupted.
+                LL_WARNS("AssetStorage") << "LLViewerAssetStorage::storeAssetData()  Data _should_ already be in the cache, but it's not! " << asset_id << LL_ENDL;
 
                 delete req;
                 if (callback)
                 {
-                    callback(asset_id, user_data, LL_ERR_ASSET_REQUEST_FAILED, LLExtStat::VFS_CORRUPT);
+                    callback(asset_id, user_data, LL_ERR_ASSET_REQUEST_FAILED, LLExtStat::CACHE_CORRUPT);
                 }
                 return;
             }
             else
             {
                 // LLAssetStorage metric: Successful Request
-                S32 size = mVFS->getSize(asset_id, asset_type);
+                S32 size = LLFileSystem::getFileSize(asset_id, asset_type);
                 const char *message = "Added to upload queue";
                 reportMetric( asset_id, asset_type, LLStringUtil::null, LLUUID::null, size, MR_OKAY, __FILE__, __LINE__, message );
 
@@ -211,7 +204,7 @@ void LLViewerAssetStorage::storeAssetData(
                 }
             }
 
-            // Read the data from the VFS if it'll fit in this packet.
+            // Read the data from the cache if it'll fit in this packet.
             if (asset_size + 100 < MTUBYTES)
             {
                 BOOL res = vfile.read(buffer, asset_size);      /* Flawfinder: ignore */
@@ -224,14 +217,11 @@ void LLViewerAssetStorage::storeAssetData(
                 }
                 else
                 {
-                    LL_WARNS("AssetStorage") << "Probable corruption in VFS file, aborting store asset data" << LL_ENDL;
-
-                    // LLAssetStorage metric: VFS corrupt - bogus size
-                    reportMetric( asset_id, asset_type, LLStringUtil::null, LLUUID::null, asset_size, MR_VFS_CORRUPTION, __FILE__, __LINE__, "VFS corruption" );
+                    LL_WARNS("AssetStorage") << "Probable corruption in cache file, aborting store asset data" << LL_ENDL;
 
                     if (callback)
                     {
-                        callback(asset_id, user_data, LL_ERR_ASSET_REQUEST_NONEXISTENT_FILE, LLExtStat::VFS_CORRUPT);
+                        callback(asset_id, user_data, LL_ERR_ASSET_REQUEST_NONEXISTENT_FILE, LLExtStat::CACHE_CORRUPT);
                     }
                     return;
                 }
@@ -254,8 +244,7 @@ void LLViewerAssetStorage::storeAssetData(
         else
         {
             LL_WARNS("AssetStorage") << "AssetStorage: attempt to upload non-existent vfile " << asset_id << ":" << LLAssetType::lookup(asset_type) << LL_ENDL;
-            // LLAssetStorage metric: Zero size VFS
-            reportMetric( asset_id, asset_type, LLStringUtil::null, LLUUID::null, 0, MR_ZERO_SIZE, __FILE__, __LINE__, "The file didn't exist or was zero length (VFS - can't tell which)" );
+            reportMetric( asset_id, asset_type, LLStringUtil::null, LLUUID::null, 0, MR_ZERO_SIZE, __FILE__, __LINE__, "The file didn't exist or was zero length (cache - can't tell which)" );
             if (callback)
             {
                 callback(asset_id, user_data,  LL_ERR_ASSET_REQUEST_NONEXISTENT_FILE, LLExtStat::NONEXISTENT_FILE);
@@ -288,7 +277,6 @@ void LLViewerAssetStorage::storeAssetData(
     if(filename.empty())
     {
         // LLAssetStorage metric: no filename
-        reportMetric( LLUUID::null, asset_type, LLStringUtil::null, LLUUID::null, 0, MR_VFS_CORRUPTION, __FILE__, __LINE__, "Filename missing" );
         LL_ERRS() << "No filename specified" << LL_ENDL;
         return;
     }
@@ -313,9 +301,7 @@ void LLViewerAssetStorage::storeAssetData(
         legacy->mUpCallback = callback;
         legacy->mUserData = user_data;
 
-        LLVFile file(mVFS, asset_id, asset_type, LLVFile::WRITE);
-
-        file.setMaxSize(size);
+        LLFileSystem file(asset_id, asset_type, LLFileSystem::APPEND);
 
         const S32 buf_size = 65536;
         U8 copy_buf[buf_size];
@@ -584,21 +570,20 @@ void LLViewerAssetStorage::assetRequestCoro(
 			// case.
             LLUUID temp_id;
             temp_id.generate();
-            LLVFile vf(gAssetStorage->mVFS, temp_id, atype, LLVFile::WRITE);
-            vf.setMaxSize(size);
+            LLFileSystem vf(temp_id, atype, LLFileSystem::WRITE);
             req->mBytesFetched = size;
             if (!vf.write(raw.data(),size))
             {
                 // TODO asset-http: handle error
                 LL_WARNS("ViewerAsset") << "Failure in vf.write()" << LL_ENDL;
                 result_code = LL_ERR_ASSET_REQUEST_FAILED;
-                ext_status = LLExtStat::VFS_CORRUPT;
+                ext_status = LLExtStat::CACHE_CORRUPT;
             }
             else if (!vf.rename(uuid, atype))
             {
                 LL_WARNS("ViewerAsset") << "rename failed" << LL_ENDL;
                 result_code = LL_ERR_ASSET_REQUEST_FAILED;
-                ext_status = LLExtStat::VFS_CORRUPT;
+                ext_status = LLExtStat::CACHE_CORRUPT;
             }
             else
             {
diff --git a/indra/newview/llviewerassetstorage.h b/indra/newview/llviewerassetstorage.h
index c1a5534b81..af7fbb5fbf 100644
--- a/indra/newview/llviewerassetstorage.h
+++ b/indra/newview/llviewerassetstorage.h
@@ -30,18 +30,16 @@
 #include "llassetstorage.h"
 #include "llcorehttputil.h"
 
-class LLVFile;
+class LLFileSystem;
 
 class LLViewerAssetRequest;
 
 class LLViewerAssetStorage : public LLAssetStorage
 {
 public:
-	LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
-				   LLVFS *vfs, LLVFS *static_vfs, const LLHost &upstream_host);
+	LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *xfer, const LLHost &upstream_host);
 
-	LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
-				   LLVFS *vfs, LLVFS *static_vfs);
+	LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *xfer);
 
 	~LLViewerAssetStorage();
 
diff --git a/indra/newview/llviewerassetupload.cpp b/indra/newview/llviewerassetupload.cpp
index 0df6811f6a..3f7e8531fb 100644
--- a/indra/newview/llviewerassetupload.cpp
+++ b/indra/newview/llviewerassetupload.cpp
@@ -45,7 +45,7 @@
 #include "llviewerassetupload.h"
 #include "llappviewer.h"
 #include "llviewerstats.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
 #include "llgesturemgr.h"
 #include "llpreviewnotecard.h"
 #include "llpreviewgesture.h"
@@ -467,15 +467,13 @@ LLSD LLNewFileResourceUploadInfo::exportTempFile()
 
     setAssetType(assetType);
 
-    // copy this file into the vfs for upload
+    // copy this file into the cache for upload
     S32 file_size;
     LLAPRFile infile;
     infile.open(filename, LL_APR_RB, NULL, &file_size);
     if (infile.getFileHandle())
     {
-        LLVFile file(gVFS, getAssetId(), assetType, LLVFile::WRITE);
-
-        file.setMaxSize(file_size);
+        LLFileSystem file(getAssetId(), assetType, LLFileSystem::APPEND);
 
         const S32 buf_size = 65536;
         U8 copy_buf[buf_size];
@@ -507,7 +505,7 @@ LLBufferedAssetUploadInfo::LLBufferedAssetUploadInfo(LLUUID itemId, LLAssetType:
     mContents(buffer),
     mInvnFinishFn(finish),
     mTaskFinishFn(nullptr),
-    mStoredToVFS(false)
+    mStoredToCache(false)
 {
     setItemId(itemId);
     setAssetType(assetType);
@@ -521,7 +519,7 @@ LLBufferedAssetUploadInfo::LLBufferedAssetUploadInfo(LLUUID itemId, LLPointer<LL
     mContents(),
     mInvnFinishFn(finish),
     mTaskFinishFn(nullptr),
-    mStoredToVFS(false)
+    mStoredToCache(false)
 {
     setItemId(itemId);
 
@@ -555,7 +553,7 @@ LLBufferedAssetUploadInfo::LLBufferedAssetUploadInfo(LLUUID taskId, LLUUID itemI
     mContents(buffer),
     mInvnFinishFn(nullptr),
     mTaskFinishFn(finish),
-    mStoredToVFS(false)
+    mStoredToCache(false)
 {
     setItemId(itemId);
     setAssetType(assetType);
@@ -566,13 +564,12 @@ LLSD LLBufferedAssetUploadInfo::prepareUpload()
     if (getAssetId().isNull())
         generateNewAssetId();
 
-    LLVFile file(gVFS, getAssetId(), getAssetType(), LLVFile::APPEND);
+    LLFileSystem file(getAssetId(), getAssetType(), LLFileSystem::APPEND);
 
     S32 size = mContents.length() + 1;
-    file.setMaxSize(size);
     file.write((U8*)mContents.c_str(), size);
 
-    mStoredToVFS = true;
+    mStoredToCache = true;
 
     return LLSD().with("success", LLSD::Boolean(true));
 }
@@ -595,10 +592,10 @@ LLUUID LLBufferedAssetUploadInfo::finishUpload(LLSD &result)
     LLUUID newAssetId = result["new_asset"].asUUID();
     LLUUID itemId = getItemId();
 
-    if (mStoredToVFS)
+    if (mStoredToCache)
     {
         LLAssetType::EType assetType(getAssetType());
-        gVFS->renameFile(getAssetId(), assetType, newAssetId, assetType);
+        LLFileSystem::renameFile(getAssetId(), assetType, newAssetId, assetType);
     }
 
     if (mTaskUpload)
diff --git a/indra/newview/llviewerassetupload.h b/indra/newview/llviewerassetupload.h
index d9eacf3167..e56ba7d8f7 100644
--- a/indra/newview/llviewerassetupload.h
+++ b/indra/newview/llviewerassetupload.h
@@ -197,7 +197,7 @@ private:
     std::string         mContents;
     invnUploadFinish_f  mInvnFinishFn;
     taskUploadFinish_f  mTaskFinishFn;
-    bool                mStoredToVFS;
+    bool                mStoredToCache;
 };
 
 //-------------------------------------------------------------------------
diff --git a/indra/newview/llviewercontrol.cpp b/indra/newview/llviewercontrol.cpp
index 89c600fc2c..bc425123e1 100644
--- a/indra/newview/llviewercontrol.cpp
+++ b/indra/newview/llviewercontrol.cpp
@@ -162,6 +162,17 @@ static bool handleSetShaderChanged(const LLSD& newvalue)
 	return true;
 }
 
+static bool handleAvatarVPChanged(const LLSD& newvalue)
+{
+    LLRenderTarget::sUseFBO = newvalue.asBoolean()
+                                && gSavedSettings.getBOOL("RenderObjectBump")
+                                && gSavedSettings.getBOOL("RenderTransparentWater")
+                                && gSavedSettings.getBOOL("RenderDeferred");
+
+    handleSetShaderChanged(LLSD());
+    return true;
+}
+
 static bool handleRenderPerfTestChanged(const LLSD& newvalue)
 {
        bool status = !newvalue.asBoolean();
@@ -201,7 +212,10 @@ static bool handleRenderPerfTestChanged(const LLSD& newvalue)
 
 bool handleRenderTransparentWaterChanged(const LLSD& newvalue)
 {
-	LLRenderTarget::sUseFBO = newvalue.asBoolean();
+    LLRenderTarget::sUseFBO = newvalue.asBoolean() 
+                                && gSavedSettings.getBOOL("RenderObjectBump") 
+                                && gSavedSettings.getBOOL("RenderAvatarVP") 
+                                && gSavedSettings.getBOOL("RenderDeferred");
 	if (gPipeline.isInit())
 	{
 		gPipeline.updateRenderTransparentWater();
@@ -454,7 +468,10 @@ static bool handleRenderDeferredChanged(const LLSD& newvalue)
 //
 static bool handleRenderBumpChanged(const LLSD& newval)
 {
-	LLRenderTarget::sUseFBO = newval.asBoolean();
+    LLRenderTarget::sUseFBO = newval.asBoolean() 
+                                && gSavedSettings.getBOOL("RenderTransparentWater") 
+                                && gSavedSettings.getBOOL("RenderAvatarVP")
+                                && gSavedSettings.getBOOL("RenderDeferred");
 	if (gPipeline.isInit())
 	{
 		gPipeline.updateRenderBump();
@@ -648,7 +665,7 @@ void settings_setup_listeners()
 	gSavedSettings.getControl("OctreeAttachmentSizeFactor")->getSignal()->connect(boost::bind(&handleRepartition, _2));
 	gSavedSettings.getControl("RenderMaxTextureIndex")->getSignal()->connect(boost::bind(&handleSetShaderChanged, _2));
 	gSavedSettings.getControl("RenderUseTriStrips")->getSignal()->connect(boost::bind(&handleResetVertexBuffersChanged, _2));
-	gSavedSettings.getControl("RenderAvatarVP")->getSignal()->connect(boost::bind(&handleSetShaderChanged, _2));
+	gSavedSettings.getControl("RenderAvatarVP")->getSignal()->connect(boost::bind(&handleAvatarVPChanged, _2));
 	gSavedSettings.getControl("RenderUIBuffer")->getSignal()->connect(boost::bind(&handleWindowResized, _2));
 	gSavedSettings.getControl("RenderDepthOfField")->getSignal()->connect(boost::bind(&handleReleaseGLBufferChanged, _2));
 	gSavedSettings.getControl("RenderFSAASamples")->getSignal()->connect(boost::bind(&handleReleaseGLBufferChanged, _2));
diff --git a/indra/newview/llviewerfloaterreg.cpp b/indra/newview/llviewerfloaterreg.cpp
index 5a05f89758..62d73063aa 100644
--- a/indra/newview/llviewerfloaterreg.cpp
+++ b/indra/newview/llviewerfloaterreg.cpp
@@ -33,6 +33,7 @@
 #include "llcommandhandler.h"
 #include "llcompilequeue.h"
 #include "llfasttimerview.h"
+#include "llfloater360capture.h"
 #include "llfloaterabout.h"
 #include "llfloateraddpaymentmethod.h"
 #include "llfloaterauction.h"
@@ -195,6 +196,7 @@ void LLViewerFloaterReg::registerFloaters()
 	// *NOTE: Please keep these alphabetized for easier merges
 
 	LLFloaterAboutUtil::registerFloater();
+	LLFloaterReg::add("360capture", "floater_360capture.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloater360Capture>);
 	LLFloaterReg::add("block_timers", "floater_fast_timers.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFastTimerView>);
 	LLFloaterReg::add("about_land", "floater_about_land.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterLand>);
 	LLFloaterReg::add("add_payment_method", "floater_add_payment_method.xml", (LLFloaterBuildFunc)&LLFloaterReg::build<LLFloaterAddPaymentMethod>);
diff --git a/indra/newview/llviewermedia.cpp b/indra/newview/llviewermedia.cpp
index 0c66cad9ab..3f476765cd 100644
--- a/indra/newview/llviewermedia.cpp
+++ b/indra/newview/llviewermedia.cpp
@@ -1752,8 +1752,16 @@ LLPluginClassMedia* LLViewerMediaImpl::newSourceFromMediaType(std::string media_
 			media_source->cookies_enabled( cookies_enabled || clean_browser);
 
 			// collect 'javascript enabled' setting from prefs and send to embedded browser
-			bool javascript_enabled = gSavedSettings.getBOOL( "BrowserJavascriptEnabled" );
-			media_source->setJavascriptEnabled( javascript_enabled || clean_browser);
+			bool javascript_enabled = gSavedSettings.getBOOL("BrowserJavascriptEnabled");
+			media_source->setJavascriptEnabled(javascript_enabled || clean_browser);
+
+			// collect 'web security disabled' (see Chrome --web-security-disabled) setting from prefs and send to embedded browser
+			bool web_security_disabled = gSavedSettings.getBOOL("BrowserWebSecurityDisabled");
+			media_source->setWebSecurityDisabled(web_security_disabled || clean_browser);
+
+			// collect setting indicates if local file access from file URLs is allowed from prefs and send to embedded browser
+			bool file_access_from_file_urls = gSavedSettings.getBOOL("BrowserFileAccessFromFileUrls");
+			media_source->setFileAccessFromFileUrlsEnabled(file_access_from_file_urls || clean_browser);
 
 			// As of SL-15559 PDF files do not load in CEF v91 we enable plugins
 			// but explicitly disable Flash (PDF support in CEF is now treated as a plugin)
@@ -1915,6 +1923,15 @@ void LLViewerMediaImpl::loadURI()
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::executeJavaScript(const std::string& code)
+{
+	if (mMediaSource)
+	{
+		mMediaSource->executeJavaScript(code);
+	}
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMediaImpl::setSize(int width, int height)
 {
 	mMediaWidth = width;
@@ -3207,8 +3224,19 @@ void LLViewerMediaImpl::handleMediaEvent(LLPluginClassMedia* plugin, LLPluginCla
 
 		case LLViewerMediaObserver::MEDIA_EVENT_FILE_DOWNLOAD:
 		{
-			//llinfos << "Media event - file download requested - filename is " << self->getFileDownloadFilename() << llendl;
-			LLNotificationsUtil::add("MediaFileDownloadUnsupported");
+			LL_DEBUGS("Media") << "Media event - file download requested - filename is " << plugin->getFileDownloadFilename() << LL_ENDL;
+			// pick a file from SAVE FILE dialog
+
+			// need a better algorithm that this or else, pass in type of save type
+			// from event that initiated it - this is okay for now - only thing
+			// that saves is 360s
+			std::string suggested_filename = plugin->getFileDownloadFilename();
+			LLFilePicker::ESaveFilter filter = LLFilePicker::FFSAVE_ALL;
+			if (suggested_filename.find(".jpg") != std::string::npos || suggested_filename.find(".jpeg") != std::string::npos)
+				filter = LLFilePicker::FFSAVE_JPEG;
+			if (suggested_filename.find(".png") != std::string::npos)
+				filter = LLFilePicker::FFSAVE_PNG;
+			init_threaded_picker_save_dialog(plugin, filter, suggested_filename);
 		}
 		break;
 
diff --git a/indra/newview/llviewermedia.h b/indra/newview/llviewermedia.h
index 8bf1ad2441..71cec5125d 100644
--- a/indra/newview/llviewermedia.h
+++ b/indra/newview/llviewermedia.h
@@ -207,6 +207,7 @@ public:
 	bool initializeMedia(const std::string& mime_type);
 	bool initializePlugin(const std::string& media_type);
 	void loadURI();
+	void executeJavaScript(const std::string& code);
 	LLPluginClassMedia* getMediaPlugin() { return mMediaSource.get(); }
 	void setSize(int width, int height);
 
diff --git a/indra/newview/llviewermedia_streamingaudio.cpp b/indra/newview/llviewermedia_streamingaudio.cpp
index 3ccf3070ab..d3e24aece5 100644
--- a/indra/newview/llviewermedia_streamingaudio.cpp
+++ b/indra/newview/llviewermedia_streamingaudio.cpp
@@ -33,10 +33,8 @@
 #include "llviewermedia_streamingaudio.h"
 
 #include "llmimetypes.h"
-#include "llvfs.h"
 #include "lldir.h"
 
-
 LLStreamingAudio_MediaPlugins::LLStreamingAudio_MediaPlugins() :
 	mMediaPlugin(NULL),
 	mGain(1.0)
diff --git a/indra/newview/llviewermenu.cpp b/indra/newview/llviewermenu.cpp
index dfc43ab439..7d8726e226 100644
--- a/indra/newview/llviewermenu.cpp
+++ b/indra/newview/llviewermenu.cpp
@@ -1273,12 +1273,55 @@ class LLAdvancedDumpScriptedCamera : public view_listener_t
 class LLAdvancedDumpRegionObjectCache : public view_listener_t
 {
 	bool handleEvent(const LLSD& userdata)
-{
+	{
 		handle_dump_region_object_cache(NULL);
 		return true;
 	}
 };
 
+class LLAdvancedInterestListFullUpdate : public view_listener_t
+{
+	bool handleEvent(const LLSD& userdata)
+	{
+		LLSD request;
+		LLSD body;
+		static bool using_360 = false;
+
+		if (using_360)
+		{
+			body["mode"] = LLSD::String("default");
+		}
+		else
+		{
+			body["mode"] = LLSD::String("360");
+		}
+		using_360 = !using_360;
+
+        if (gAgent.requestPostCapability("InterestList", body, [](const LLSD& response)
+        {
+            LL_INFOS("360Capture") <<
+                "InterestList capability responded: \n" <<
+                ll_pretty_print_sd(response) <<
+                LL_ENDL;
+        }))
+        {
+            LL_INFOS("360Capture") <<
+                "Successfully posted an InterestList capability request with payload: \n" <<
+                ll_pretty_print_sd(body) <<
+                LL_ENDL;
+            return true;
+        }
+        else
+        {
+            LL_INFOS("360Capture") <<
+                "Unable to post an InterestList capability request with payload: \n" <<
+                ll_pretty_print_sd(body) <<
+                LL_ENDL;
+            return false;
+        }
+	}
+};
+
 class LLAdvancedBuyCurrencyTest : public view_listener_t
 	{
 	bool handleEvent(const LLSD& userdata)
@@ -2319,11 +2362,10 @@ class LLAdvancedLeaveAdminStatus : public view_listener_t
 // Advanced > Debugging //
 //////////////////////////
 
-
 class LLAdvancedForceErrorBreakpoint : public view_listener_t
 {
 	bool handleEvent(const LLSD& userdata)
-	{
+	{		
 		force_error_breakpoint(NULL);
 		return true;
 	}
@@ -9229,6 +9271,7 @@ void initialize_menus()
 	// Advanced > World
 	view_listener_t::addMenu(new LLAdvancedDumpScriptedCamera(), "Advanced.DumpScriptedCamera");
 	view_listener_t::addMenu(new LLAdvancedDumpRegionObjectCache(), "Advanced.DumpRegionObjectCache");
+	view_listener_t::addMenu(new LLAdvancedInterestListFullUpdate(), "Advanced.InterestListFullUpdate");
 
 	// Advanced > UI
 	commit.add("Advanced.WebBrowserTest", boost::bind(&handle_web_browser_test,	_2));	// sigh! this one opens the MEDIA browser
diff --git a/indra/newview/llviewermenufile.cpp b/indra/newview/llviewermenufile.cpp
index 15181dcd9f..4efc3d1cb3 100644
--- a/indra/newview/llviewermenufile.cpp
+++ b/indra/newview/llviewermenufile.cpp
@@ -53,8 +53,6 @@
 #include "llviewercontrol.h"	// gSavedSettings
 #include "llviewertexturelist.h"
 #include "lluictrlfactory.h"
-#include "llvfile.h"
-#include "llvfs.h"
 #include "llviewerinventory.h"
 #include "llviewermenu.h"	// gMenuHolder
 #include "llviewerparcelmgr.h"
diff --git a/indra/newview/llviewermessage.cpp b/indra/newview/llviewermessage.cpp
index 9d85586dae..14442c9705 100644
--- a/indra/newview/llviewermessage.cpp
+++ b/indra/newview/llviewermessage.cpp
@@ -45,8 +45,7 @@
 #include "llteleportflags.h"
 #include "lltoastnotifypanel.h"
 #include "lltransactionflags.h"
-#include "llvfile.h"
-#include "llvfs.h"
+#include "llfilesystem.h"
 #include "llxfermanager.h"
 #include "mean_collision_data.h"
 
@@ -3746,6 +3745,7 @@ void process_kill_object(LLMessageSystem *mesgsys, void **user_data)
 				{
 					LLColor4 color(0.f,1.f,0.f,1.f);
 					gPipeline.addDebugBlip(objectp->getPositionAgent(), color);
+					LL_DEBUGS("MessageBlip") << "Kill blip for local " << local_id << " at " << objectp->getPositionAgent() << LL_ENDL;
 				}
 
 				// Do the kill
@@ -6430,15 +6430,12 @@ void process_user_info_reply(LLMessageSystem* msg, void**)
 				<< "wrong agent id." << LL_ENDL;
 	}
 	
-	BOOL im_via_email;
-	msg->getBOOLFast(_PREHASH_UserData, _PREHASH_IMViaEMail, im_via_email);
 	std::string email;
 	msg->getStringFast(_PREHASH_UserData, _PREHASH_EMail, email);
 	std::string dir_visibility;
 	msg->getString( "UserData", "DirectoryVisibility", dir_visibility);
 
-    // For Message based user info information the is_verified is assumed to be false.
-	LLFloaterPreference::updateUserInfo(dir_visibility, im_via_email, false);   
+	LLFloaterPreference::updateUserInfo(dir_visibility);   
 	LLFloaterSnapshot::setAgentEmail(email);
 }
 
@@ -6857,16 +6854,15 @@ void process_covenant_reply(LLMessageSystem* msg, void**)
 	}
 }
 
-void onCovenantLoadComplete(LLVFS *vfs,
-					const LLUUID& asset_uuid,
-					LLAssetType::EType type,
-					void* user_data, S32 status, LLExtStat ext_status)
+void onCovenantLoadComplete(const LLUUID& asset_uuid,
+							LLAssetType::EType type,
+							void* user_data, S32 status, LLExtStat ext_status)
 {
 	LL_DEBUGS("Messaging") << "onCovenantLoadComplete()" << LL_ENDL;
 	std::string covenant_text;
 	if(0 == status)
 	{
-		LLVFile file(vfs, asset_uuid, type, LLVFile::READ);
+		LLFileSystem file(asset_uuid, type, LLFileSystem::READ);
 		
 		S32 file_length = file.getSize();
 		
diff --git a/indra/newview/llviewermessage.h b/indra/newview/llviewermessage.h
index 78829a6a56..1e5a69ae13 100644
--- a/indra/newview/llviewermessage.h
+++ b/indra/newview/llviewermessage.h
@@ -47,7 +47,6 @@ class LLInventoryObject;
 class LLInventoryItem;
 class LLMeanCollisionData;
 class LLMessageSystem;
-class LLVFS;
 class LLViewerObject;
 class LLViewerRegion;
 
@@ -189,8 +188,7 @@ void process_script_dialog(LLMessageSystem* msg, void**);
 void process_load_url(LLMessageSystem* msg, void**);
 void process_script_teleport_request(LLMessageSystem* msg, void**);
 void process_covenant_reply(LLMessageSystem* msg, void**);
-void onCovenantLoadComplete(LLVFS *vfs,
-							const LLUUID& asset_uuid,
+void onCovenantLoadComplete(const LLUUID& asset_uuid,
 							LLAssetType::EType type,
 							void* user_data, S32 status, LLExtStat ext_status);
 
diff --git a/indra/newview/llviewerobject.cpp b/indra/newview/llviewerobject.cpp
index b88baf6aa7..31e80eb865 100644
--- a/indra/newview/llviewerobject.cpp
+++ b/indra/newview/llviewerobject.cpp
@@ -2402,6 +2402,7 @@ U32 LLViewerObject::processUpdateMessage(LLMessageSystem *mesgsys,
 			color.setVec(1.f, 0.f, 0.f, 1.f);
 		}
 		gPipeline.addDebugBlip(getPositionAgent(), color);
+		LL_DEBUGS("MessageBlip") << "Update type " << (S32)update_type << " blip for local " << mLocalID << " at " << getPositionAgent() << LL_ENDL;
 	}
 
 	const F32 MAG_CUTOFF = F_APPROXIMATELY_ZERO;
diff --git a/indra/newview/llviewerprecompiledheaders.h b/indra/newview/llviewerprecompiledheaders.h
index bbbacce8fa..e378c2448a 100644
--- a/indra/newview/llviewerprecompiledheaders.h
+++ b/indra/newview/llviewerprecompiledheaders.h
@@ -101,7 +101,6 @@
 #include "v4math.h"
 #include "xform.h"
 
-// Library includes from llvfs
 #include "lldir.h"
 
 // Library includes from llmessage project
diff --git a/indra/newview/llviewerregion.cpp b/indra/newview/llviewerregion.cpp
index c8bb4901d3..4479667edb 100644
--- a/indra/newview/llviewerregion.cpp
+++ b/indra/newview/llviewerregion.cpp
@@ -2973,6 +2973,8 @@ void LLViewerRegionImpl::buildCapabilityNames(LLSD& capabilityNames)
 	capabilityNames.append("IncrementCOFVersion");
 	AISAPI::getCapNames(capabilityNames);
 
+	capabilityNames.append("InterestList");
+
 	capabilityNames.append("GetDisplayNames");
 	capabilityNames.append("GetExperiences");
 	capabilityNames.append("AgentExperiences");
diff --git a/indra/newview/llviewerstats.cpp b/indra/newview/llviewerstats.cpp
index 98d13f8979..3fe55f9fba 100644
--- a/indra/newview/llviewerstats.cpp
+++ b/indra/newview/llviewerstats.cpp
@@ -33,7 +33,6 @@
 #include "llfloaterreg.h"
 #include "llmemory.h"
 #include "lltimer.h"
-#include "llvfile.h"
 
 #include "llappviewer.h"
 
@@ -146,7 +145,6 @@ LLTrace::SampleStatHandle<>	FPS_SAMPLE("fpssample"),
 							VISIBLE_AVATARS("visibleavatars", "Visible Avatars"),
 							SHADER_OBJECTS("shaderobjects", "Object Shaders"),
 							DRAW_DISTANCE("drawdistance", "Draw Distance"),
-							PENDING_VFS_OPERATIONS("vfspendingoperations"),
 							WINDOW_WIDTH("windowwidth", "Window width"),
 							WINDOW_HEIGHT("windowheight", "Window height");
 
@@ -385,7 +383,6 @@ void update_statistics()
 	F64Bits layer_bits = gVLManager.getLandBits() + gVLManager.getWindBits() + gVLManager.getCloudBits();
 	add(LLStatViewer::LAYERS_NETWORK_DATA_RECEIVED, layer_bits);
 	add(LLStatViewer::OBJECT_NETWORK_DATA_RECEIVED, gObjectData);
-	sample(LLStatViewer::PENDING_VFS_OPERATIONS, LLVFile::getVFSThread()->getPending());
 	add(LLStatViewer::ASSET_UDP_DATA_RECEIVED, F64Bits(gTransferManager.getTransferBitsIn(LLTCT_ASSET)));
 	gTransferManager.resetTransferBitsIn(LLTCT_ASSET);
 
diff --git a/indra/newview/llviewerstats.h b/indra/newview/llviewerstats.h
index 64b4628daa..4468e44ea8 100644
--- a/indra/newview/llviewerstats.h
+++ b/indra/newview/llviewerstats.h
@@ -186,7 +186,6 @@ extern LLTrace::SampleStatHandle<>		FPS_SAMPLE,
 										VISIBLE_AVATARS,
 										SHADER_OBJECTS,
 										DRAW_DISTANCE,
-										PENDING_VFS_OPERATIONS,
 										WINDOW_WIDTH,
 										WINDOW_HEIGHT;
 
diff --git a/indra/newview/llviewertexlayer.cpp b/indra/newview/llviewertexlayer.cpp
index c501dd0035..4c2fbcf837 100644
--- a/indra/newview/llviewertexlayer.cpp
+++ b/indra/newview/llviewertexlayer.cpp
@@ -31,8 +31,6 @@
 #include "llagent.h"
 #include "llimagej2c.h"
 #include "llnotificationsutil.h"
-#include "llvfile.h"
-#include "llvfs.h"
 #include "llviewerregion.h"
 #include "llglslshader.h"
 #include "llvoavatarself.h"
diff --git a/indra/newview/llviewertexture.cpp b/indra/newview/llviewertexture.cpp
index 7fbc4d789b..075588d577 100644
--- a/indra/newview/llviewertexture.cpp
+++ b/indra/newview/llviewertexture.cpp
@@ -39,8 +39,6 @@
 #include "llimagej2c.h"
 #include "llimagetga.h"
 #include "llstl.h"
-#include "llvfile.h"
-#include "llvfs.h"
 #include "message.h"
 #include "lltimer.h"
 
diff --git a/indra/newview/llviewertexture.h b/indra/newview/llviewertexture.h
index 7b4b3d940f..0de49073c8 100644
--- a/indra/newview/llviewertexture.h
+++ b/indra/newview/llviewertexture.h
@@ -54,7 +54,7 @@ class LLTexturePipelineTester ;
 
 typedef	void	(*loaded_callback_func)( BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* src_aux, S32 discard_level, BOOL final, void* userdata );
 
-class LLVFile;
+class LLFileSystem;
 class LLMessageSystem;
 class LLViewerMediaImpl ;
 class LLVOVolume ;
diff --git a/indra/newview/llviewertexturelist.cpp b/indra/newview/llviewertexturelist.cpp
index 82973d3278..37344056e1 100644
--- a/indra/newview/llviewertexturelist.cpp
+++ b/indra/newview/llviewertexturelist.cpp
@@ -41,9 +41,7 @@
 
 #include "llsdserialize.h"
 #include "llsys.h"
-#include "llvfs.h"
-#include "llvfile.h"
-#include "llvfsthread.h"
+#include "llfilesystem.h"
 #include "llxmltree.h"
 #include "message.h"
 
diff --git a/indra/newview/llviewerwearable.cpp b/indra/newview/llviewerwearable.cpp
index c80cf27bda..bc21b5bf84 100644
--- a/indra/newview/llviewerwearable.cpp
+++ b/indra/newview/llviewerwearable.cpp
@@ -107,7 +107,6 @@ LLWearable::EImportResult LLViewerWearable::importStream( std::istream& input_st
 		// Shouldn't really log the asset id for security reasons, but
 		// we need it in this case.
 		LL_WARNS() << "Bad Wearable asset header: " << mAssetID << LL_ENDL;
-		//gVFS->dumpMap();
 		return result;
 	}
 
diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp
index 9e0f554a0a..050fb454ad 100644
--- a/indra/newview/llviewerwindow.cpp
+++ b/indra/newview/llviewerwindow.cpp
@@ -5178,6 +5178,104 @@ BOOL LLViewerWindow::rawSnapshot(LLImageRaw *raw, S32 image_width, S32 image_hei
 	return ret;
 }
 
+BOOL LLViewerWindow::simpleSnapshot(LLImageRaw* raw, S32 image_width, S32 image_height, const int num_render_passes)
+{
+    gDisplaySwapBuffers = FALSE;
+
+    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+    setCursor(UI_CURSOR_WAIT);
+
+    BOOL prev_draw_ui = gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_UI) ? TRUE : FALSE;
+    if (prev_draw_ui != false)
+    {
+        LLPipeline::toggleRenderDebugFeature(LLPipeline::RENDER_DEBUG_FEATURE_UI);
+    }
+
+    LLPipeline::sShowHUDAttachments = FALSE;
+    LLRect window_rect = getWorldViewRectRaw();
+
+    S32 original_width = LLPipeline::sRenderDeferred ? gPipeline.mDeferredScreen.getWidth() : gViewerWindow->getWorldViewWidthRaw();
+    S32 original_height = LLPipeline::sRenderDeferred ? gPipeline.mDeferredScreen.getHeight() : gViewerWindow->getWorldViewHeightRaw();
+
+    LLRenderTarget scratch_space;
+    U32 color_fmt = GL_RGBA;
+    const bool use_depth_buffer = true;
+    const bool use_stencil_buffer = true;
+    if (scratch_space.allocate(image_width, image_height, color_fmt, use_depth_buffer, use_stencil_buffer))
+    {
+        if (gPipeline.allocateScreenBuffer(image_width, image_height))
+        {
+            mWorldViewRectRaw.set(0, image_height, image_width, 0);
+
+            scratch_space.bindTarget();
+        }
+        else
+        {
+            scratch_space.release();
+            gPipeline.allocateScreenBuffer(original_width, original_height);
+        }
+    }
+
+    // we render the scene more than once since this helps
+    // greatly with the objects not being drawn in the 
+    // snapshot when they are drawn in the scene. This is 
+    // evident when you set this value via the debug setting
+    // called 360CaptureNumRenderPasses to 1. The theory is
+    // that the missing objects are caused by the sUseOcclusion
+    // property in pipeline but that the use in pipeline.cpp
+    // lags by a frame or two so rendering more than once
+    // appears to help a lot.
+    for (int i = 0; i < num_render_passes; ++i)
+    {
+        // turning this flag off here prohibits the screen swap
+        // to present the new page to the viewer - this stops
+        // the black flash in between captures when the number
+        // of render passes is more than 1. We need to also
+        // set it here because code in LLViewerDisplay resets
+        // it to TRUE each time.
+        gDisplaySwapBuffers = FALSE;
+
+        // actually render the scene
+        const U32 subfield = 0;
+        const bool do_rebuild = true;
+        const F32 zoom = 1.0;
+        const bool for_snapshot = TRUE;
+        display(do_rebuild, zoom, subfield, for_snapshot);
+    }
+
+    glReadPixels(
+        0, 0,
+        image_width,
+        image_height,
+        GL_RGB, GL_UNSIGNED_BYTE,
+        raw->getData()
+    );
+    stop_glerror();
+
+    gDisplaySwapBuffers = FALSE;
+    gDepthDirty = TRUE;
+
+    if (!gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_UI))
+    {
+        if (prev_draw_ui != false)
+        {
+            LLPipeline::toggleRenderDebugFeature(LLPipeline::RENDER_DEBUG_FEATURE_UI);
+        }
+    }
+
+    LLPipeline::sShowHUDAttachments = TRUE;
+
+    setCursor(UI_CURSOR_ARROW);
+
+    gPipeline.resetDrawOrders();
+    mWorldViewRectRaw = window_rect;
+    scratch_space.flush();
+    scratch_space.release();
+    gPipeline.allocateScreenBuffer(original_width, original_height);
+
+    return true;
+}
+
 void LLViewerWindow::destroyWindow()
 {
 	if (mWindow)
diff --git a/indra/newview/llviewerwindow.h b/indra/newview/llviewerwindow.h
index 8a6df613dc..713cc51bf7 100644
--- a/indra/newview/llviewerwindow.h
+++ b/indra/newview/llviewerwindow.h
@@ -357,7 +357,10 @@ public:
 	BOOL			saveSnapshot(const std::string&  filename, S32 image_width, S32 image_height, BOOL show_ui = TRUE, BOOL show_hud = TRUE, BOOL do_rebuild = FALSE, LLSnapshotModel::ESnapshotLayerType type = LLSnapshotModel::SNAPSHOT_TYPE_COLOR, LLSnapshotModel::ESnapshotFormat format = LLSnapshotModel::SNAPSHOT_FORMAT_BMP);
 	BOOL			rawSnapshot(LLImageRaw *raw, S32 image_width, S32 image_height, BOOL keep_window_aspect = TRUE, BOOL is_texture = FALSE,
 		BOOL show_ui = TRUE, BOOL show_hud = TRUE, BOOL do_rebuild = FALSE, LLSnapshotModel::ESnapshotLayerType type = LLSnapshotModel::SNAPSHOT_TYPE_COLOR, S32 max_size = MAX_SNAPSHOT_IMAGE_SIZE);
-	BOOL			thumbnailSnapshot(LLImageRaw *raw, S32 preview_width, S32 preview_height, BOOL show_ui, BOOL show_hud, BOOL do_rebuild, LLSnapshotModel::ESnapshotLayerType type);
+
+    BOOL			simpleSnapshot(LLImageRaw *raw, S32 image_width, S32 image_height, const int num_render_passes);
+
+    BOOL			thumbnailSnapshot(LLImageRaw *raw, S32 preview_width, S32 preview_height, BOOL show_ui, BOOL show_hud, BOOL do_rebuild, LLSnapshotModel::ESnapshotLayerType type);
 	BOOL			isSnapshotLocSet() const;
 	void			resetSnapshotLoc() const;
 
diff --git a/indra/newview/llvoavatar.cpp b/indra/newview/llvoavatar.cpp
index 0e0ebce949..5d994058c2 100644
--- a/indra/newview/llvoavatar.cpp
+++ b/indra/newview/llvoavatar.cpp
@@ -1140,7 +1140,6 @@ void LLVOAvatar::initInstance()
 	//-------------------------------------------------------------------------
 	if (LLCharacter::sInstances.size() == 1)
 	{
-		LLKeyframeMotion::setVFS(gStaticVFS);
 		registerMotion( ANIM_AGENT_DO_NOT_DISTURB,					LLNullMotion::create );
 		registerMotion( ANIM_AGENT_CROUCH,					LLKeyframeStandMotion::create );
 		registerMotion( ANIM_AGENT_CROUCHWALK,				LLKeyframeWalkMotion::create );
diff --git a/indra/newview/llvovolume.h b/indra/newview/llvovolume.h
index ce400a3498..73eeec813c 100644
--- a/indra/newview/llvovolume.h
+++ b/indra/newview/llvovolume.h
@@ -218,10 +218,9 @@ public:
 				void	updateSculptTexture();
 				void    setIndexInTex(U32 ch, S32 index) { mIndexInTex[ch] = index ;}
 				void	sculpt();
-	 static     void    rebuildMeshAssetCallback(LLVFS *vfs,
-														  const LLUUID& asset_uuid,
-														  LLAssetType::EType type,
-														  void* user_data, S32 status, LLExtStat ext_status);
+	 static     void    rebuildMeshAssetCallback(const LLUUID& asset_uuid,
+												 LLAssetType::EType type,
+												 void* user_data, S32 status, LLExtStat ext_status);
 					
 				void	updateRelativeXform(bool force_identity = false);
 	/*virtual*/ BOOL	updateGeometry(LLDrawable *drawable);
diff --git a/indra/newview/skins/default/html/common/equirectangular/default.html b/indra/newview/skins/default/html/common/equirectangular/default.html
new file mode 100644
index 0000000000..227b306590
--- /dev/null
+++ b/indra/newview/skins/default/html/common/equirectangular/default.html
@@ -0,0 +1,22 @@
+<html>
+<head>
+<style>
+body {
+  background-color:#000;
+  background-image: linear-gradient(white 2px, transparent 2px),
+  linear-gradient(90deg, white 2px, transparent 2px),
+  linear-gradient(rgba(255,255,255,.3) 1px, transparent 1px),
+  linear-gradient(90deg, rgba(255,255,255,.3) 1px, transparent 1px);
+  background-size: 100px 100px, 100px 100px, 20px 20px, 20px 20px;
+  background-position:-2px -2px, -2px -2px, -1px -1px, -1px -1px;
+}
+</style>
+</head>
+<body>
+<script>
+function start() {
+}
+document.addEventListener('DOMContentLoaded', start);
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/indra/newview/skins/default/html/common/equirectangular/eqr_gen.html b/indra/newview/skins/default/html/common/equirectangular/eqr_gen.html
new file mode 100644
index 0000000000..2675d37727
--- /dev/null
+++ b/indra/newview/skins/default/html/common/equirectangular/eqr_gen.html
@@ -0,0 +1,150 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
+    <style>
+        body {
+            background: #333;
+            padding: 0;
+            margin: 0;
+            overflow: hidden;
+        }
+        #error_message {
+            z-index: 2;
+            background-color: #aa3333;
+            overflow: hidden;
+            display:  none;
+            pointer-events:none;
+            font-family: monospace;
+            font-size: 3em;
+            color: white;
+            border-radius: 1em;
+            padding: 1em;
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            margin-right: -50%;
+            transform: translate(-50%, -50%)
+        }
+        #quality_window {
+            user-select: none;
+            z-index: 100;
+            position:  absolute;
+            left: 8px;
+            top: 8px;
+            width: auto;
+            border-radius: 16px;
+            height: auto;
+            font-size: 1.5em;
+            text-align: center;
+            font-family: monospace;
+            background-color: rgba(200,200,200,0.35);
+            color: #000;
+            padding-left: 16px;
+            padding-right: 16px;
+            padding-top: 8px;
+            padding-bottom: 8px;
+        }
+    </style>
+</head>
+<body>
+    <script src="js/three.min.js"></script>
+    <script src="js/OrbitControls.js"></script>
+    <script src="js/jpeg_encoder_basic.js" type="text/javascript"></script>
+    <script src="js/CubemapToEquirectangular.js"></script>
+    <script>
+        var controls, camera, scene, renderer, equiManaged;
+
+        function init(eqr_width, eqr_height, img_path, camera_fov, initial_heading, overlay_label) {
+
+            camera = new THREE.PerspectiveCamera(camera_fov, window.innerWidth / window.innerHeight, 0.1, 100);
+            camera.position.x = 0.01;
+
+            scene = new THREE.Scene();
+
+            renderer = new THREE.WebGLRenderer();
+            renderer.autoClear = false;
+            renderer.setPixelRatio(window.devicePixelRatio);
+            renderer.setSize(window.innerWidth, window.innerHeight);
+
+            var cubemap_img_js_url = img_path + '/cubemap_img.js';
+            var cubemap_image_js = document.createElement('script');
+            cubemap_image_js.setAttribute('type', 'text/javascript');
+            cubemap_image_js.setAttribute('src', cubemap_img_js_url);
+            document.getElementsByTagName('head')[0].appendChild(cubemap_image_js);
+            cubemap_image_js.onload = function () {
+                document.getElementById("error_message").style.display = 'none' 
+                scene.background = new THREE.CubeTextureLoader().load(cubemap_img_js);
+                equiManaged = new CubemapToEquirectangular(renderer, true, eqr_width, eqr_height);
+            };
+            cubemap_image_js.onerror = function () {
+                document.getElementById("error_message").style.display = 'inline-block' 
+            };
+
+            document.body.appendChild(renderer.domElement);
+            window.addEventListener('resize', onWindowResize, false);
+
+            controls = new THREE.OrbitControls(camera, renderer.domElement);
+            controls.autoRotate = true;
+            controls.autoRotateSpeed = 0.2;
+            controls.enableZoom = false;
+            controls.enablePan = false;
+            controls.enableDamping = true;
+            controls.dampingFactor = 0.15;
+            controls.rotateSpeed = -0.5;
+
+            // initial direction the camera faces
+            // We cannot edit camera rotation directly as the OrbitControls will
+            // immediately reset it so we need some math to tell the controls
+            // there to look at initially. Note there is also an offset of π/2 since
+            // the Viewer and three.js have slightly different coordinate systems 
+            var spherical_target = new THREE.Spherical(1, Math.PI / 2, initial_heading + Math.PI / 2)
+            var target = new THREE.Vector3().setFromSpherical(spherical_target) 
+            camera.position.set(target.x, target.y, target.z);
+            controls.update();
+            controls.saveState();
+
+            // update the text that gets passed in from the C++ app for
+            // the translucent overlay label that tells us what we are seeing
+            document.getElementById('quality_window').innerHTML = overlay_label;
+
+            animate();
+        }
+
+        window.addEventListener(
+            'mousedown',
+            function (event) {
+                controls.autoRotate = false;
+            },
+            false
+        );
+
+        window.addEventListener(
+            'dblclick',
+            function (event) {
+                controls.autoRotate = true;
+            },
+            false
+        );
+
+        function saveAsEqrImage(filename, xmp_details) {
+            equiManaged.update(camera, scene, filename, xmp_details);
+        }
+
+        function onWindowResize() {
+            camera.aspect = window.innerWidth / window.innerHeight;
+            camera.updateProjectionMatrix();
+            renderer.setSize(window.innerWidth, window.innerHeight);
+        }
+
+        function animate() {
+            requestAnimationFrame(animate);
+            controls.update();
+            renderer.render(scene, camera);
+        }
+    </script>
+    <div id="error_message">UNABLE TO LOAD EQR IMAGE</div>
+    <div id="quality_window">Preview Quality</div>
+</body>
+</html>
\ No newline at end of file
diff --git a/indra/newview/skins/default/textures/textures.xml b/indra/newview/skins/default/textures/textures.xml
index 03878d9fe7..a36b859b6c 100644
--- a/indra/newview/skins/default/textures/textures.xml
+++ b/indra/newview/skins/default/textures/textures.xml
@@ -131,7 +131,8 @@ with the same filename but different name
   <texture name="Check_Mark" file_name="icons/check_mark.png" preload="true" />
 
   <texture name="Checker" file_name="checker.png" preload="false" />
-  
+
+  <texture name="Command_360_Capture_Icon"  file_name="toolbar_icons/360_capture.png"  preload="true" />
   <texture name="Command_AboutLand_Icon"    file_name="toolbar_icons/land.png"         preload="true" />
   <texture name="Command_Appearance_Icon"   file_name="toolbar_icons/appearance.png"   preload="true" />
   <texture name="Command_Avatar_Icon"       file_name="toolbar_icons/avatars.png"      preload="true" />
diff --git a/indra/newview/skins/default/textures/toolbar_icons/360_capture.png b/indra/newview/skins/default/textures/toolbar_icons/360_capture.png
new file mode 100644
index 0000000000..163cebe29f
--- /dev/null
+++ b/indra/newview/skins/default/textures/toolbar_icons/360_capture.png
diff --git a/indra/newview/skins/default/xui/da/floater_stats.xml b/indra/newview/skins/default/xui/da/floater_stats.xml
index fe3fa9626e..d07f9e48ca 100644
--- a/indra/newview/skins/default/xui/da/floater_stats.xml
+++ b/indra/newview/skins/default/xui/da/floater_stats.xml
@@ -32,7 +32,6 @@
 					<stat_bar label="Layers" name="layerskbitstat"/>
 					<stat_bar label="Actual In" name="actualinkbitstat"/>
 					<stat_bar label="Actual Out" name="actualoutkbitstat"/>
-					<stat_bar label="VFS Pending Ops" name="vfspendingoperations"/>
 				</stat_view>
 			</stat_view>
 			<stat_view label="Simulator" name="sim">
diff --git a/indra/newview/skins/default/xui/da/strings.xml b/indra/newview/skins/default/xui/da/strings.xml
index ec6ba4800d..814305c1bc 100644
--- a/indra/newview/skins/default/xui/da/strings.xml
+++ b/indra/newview/skins/default/xui/da/strings.xml
@@ -22,9 +22,6 @@
 	<string name="StartupInitializingTextureCache">
 		Initialiserer tekstur cache...
 	</string>
-	<string name="StartupInitializingVFS">
-		Initialiserer VFS...
-	</string>
 	<string name="ProgressRestoring">
 		Gendanner...
 	</string>
diff --git a/indra/newview/skins/default/xui/de/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/de/floater_scene_load_stats.xml
index dff462a594..a3749f1cfa 100644
--- a/indra/newview/skins/default/xui/de/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/de/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
 					<stat_bar label="Ebenen" name="layersdatareceived"/>
 					<stat_bar label="Tatsächlicher Eingang" name="messagedatain"/>
 					<stat_bar label="Tatsächlicher Ausgang" name="messagedataout"/>
-					<stat_bar label="Ausstehende Vorgänge im VFS" name="vfspendingoperations"/>
 				</stat_view>
 			</stat_view>
 			<stat_view label="Simulator" name="sim">
diff --git a/indra/newview/skins/default/xui/de/floater_stats.xml b/indra/newview/skins/default/xui/de/floater_stats.xml
index 4e6f56cd94..1838c2081a 100644
--- a/indra/newview/skins/default/xui/de/floater_stats.xml
+++ b/indra/newview/skins/default/xui/de/floater_stats.xml
@@ -56,7 +56,6 @@
 					<stat_bar label="Ebenen" name="layersdatareceived"/>
 					<stat_bar label="Tatsächlicher Eingang" name="messagedatain"/>
 					<stat_bar label="Tatsächlicher Ausgang" name="messagedataout"/>
-					<stat_bar label="Ausstehende Vorgänge im VFS" name="vfspendingoperations"/>
 				</stat_view>
 			</stat_view>
 			<stat_view label="Simulator" name="sim">
diff --git a/indra/newview/skins/default/xui/de/strings.xml b/indra/newview/skins/default/xui/de/strings.xml
index 43327c132d..f021e03dc7 100644
--- a/indra/newview/skins/default/xui/de/strings.xml
+++ b/indra/newview/skins/default/xui/de/strings.xml
@@ -31,9 +31,6 @@
 	<string name="StartupInitializingTextureCache">
 		Textur-Cache wird initialisiert...
 	</string>
-	<string name="StartupInitializingVFS">
-		VFS wird initialisiert...
-	</string>
 	<string name="StartupRequireDriverUpdate">
 		Grafikinitialisierung fehlgeschlagen. Bitte aktualisieren Sie Ihren Grafiktreiber.
 	</string>
@@ -73,7 +70,6 @@ LOD-Faktor: [LOD_FACTOR]
 Darstellungsqualität: [RENDER_QUALITY]
 Erweitertes Beleuchtungsmodell: [GPU_SHADERS]
 Texturspeicher: [TEXTURE_MEMORY] MB
-Erstellungszeit VFS (Cache): [VFS_TIME]
 	</string>
 	<string name="AboutOSXHiDPI">
 		HiDPI-Anzeigemodus: [HIDPI]
diff --git a/indra/newview/skins/default/xui/en/floater_360capture.xml b/indra/newview/skins/default/xui/en/floater_360capture.xml
new file mode 100644
index 0000000000..c89489d145
--- /dev/null
+++ b/indra/newview/skins/default/xui/en/floater_360capture.xml
@@ -0,0 +1,135 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<floater can_resize="true"
+         height="400"
+         layout="topleft"
+         min_height="300"
+         min_width="400"
+         name="360capture"
+         help_topic="360capture"
+         save_rect="true"
+         title="360 SNAPSHOT"
+         width="800">
+  <panel layout="topleft"
+       background_visible="true"
+       top="0"
+       follows="left|bottom|top"
+       left="0"
+       width="200"
+       bg_opaque_color="0.195 0.195 0.195 1"
+       background_opaque="true"
+       height="400"
+       name="ui_panel_left">
+    <text
+       follows="top|left|right"
+       height="16"
+       layout="topleft"
+       left="10"
+       top="10"
+       width="100">
+      Quality level
+    </text>
+    <radio_group
+      control_name="360QualitySelection"
+      follows="left|top"
+      height="94"
+      layout="topleft"
+      left_delta="20"
+      name="360_quality_selection"
+      top_pad="0"
+      width="180">
+      <radio_item
+        height="20"
+        label="Preview (fast)"
+        layout="topleft"
+        left="0"
+        name="preview_quality"
+        value="128"
+        tool_tip="Preview quality"
+        top="0"
+        width="100" />
+      <radio_item
+         height="20"
+         label="Medium"
+         layout="topleft"
+         left_delta="0"
+         name="medium_quality"
+         value="512"
+         tool_tip="Medium quality"
+         top_delta="20"
+         width="100" />
+      <radio_item
+         height="20"
+         label="High"
+         layout="topleft"
+         left_delta="0"
+         name="high_quality"
+         value="1024"
+         tool_tip="High quality"
+         top_delta="20"
+         width="100" />
+      <radio_item
+         height="20"
+         label="Maximum"
+         layout="topleft"
+         left_delta="0"
+         name="maximum_quality"
+         value="2048"
+         tool_tip="Maximum quality"
+         top_delta="20"
+         width="100" />
+    </radio_group>
+    <check_box control_name="360CaptureHideAvatars"
+               follows="left|top"
+               height="15"
+               label="Hide all avatars"
+               layout="left"
+               left="10"
+               name="360_hide_avatar"
+               top_delta="0"
+               width="100"/>
+    <button follows="left|top"
+            height="20"
+            label="Create 360 image"
+            layout="topleft"
+            left="10"
+            name="capture_button"
+            top_delta="32"
+            width="180" />
+    <button follows="left|top"
+            height="20"
+            label="Save as..."
+            layout="topleft"
+            left="10"
+            name="save_local_button"
+            top_delta="35"
+            width="180" />
+  </panel>
+  <panel layout="topleft"
+     background_visible="true"
+     top="0"
+     follows="all"
+     left="200"
+     width="600"
+     bg_opaque_color="0.195 0.195 0.195 1"
+     background_opaque="true"
+     height="400"
+     name="ui_panel_right">
+    <web_browser top="10"
+                 follows="all"
+                 bg_opaque_color="0.225 0.225 0.225 1"
+                 left="0"
+                 width="590"
+                 height="368"
+                 name="360capture_contents"
+                 trusted_content="true" />
+    <text follows="bottom"
+          layout="topleft"
+          name="statusbar"
+          height="17"
+          left="0"
+          top="382"
+          width="590">
+      Click and drag on the image to pan
+    </text>
+  </panel>
+</floater>
\ No newline at end of file
diff --git a/indra/newview/skins/default/xui/en/floater_preferences.xml b/indra/newview/skins/default/xui/en/floater_preferences.xml
index ee730dcb01..c4adf0409d 100644
--- a/indra/newview/skins/default/xui/en/floater_preferences.xml
+++ b/indra/newview/skins/default/xui/en/floater_preferences.xml
@@ -11,12 +11,6 @@
  single_instance="true"
  title="PREFERENCES"
  width="658">
-    <floater.string
-     name="email_unverified_tooltip">
-        Please verify your email to enable IM to Email by visiting
-https://accounts.secondlife.com/change_email/
-    </floater.string>
- 
    <button
      follows="right|bottom"
      height="23"
diff --git a/indra/newview/skins/default/xui/en/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/en/floater_scene_load_stats.xml
index 3f493192ff..2abd8ec5c0 100644
--- a/indra/newview/skins/default/xui/en/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/en/floater_scene_load_stats.xml
@@ -230,12 +230,6 @@
                     bar_max="1024.f"
                     tick_spacing="128.f"
                     show_bar="false"/>
-			    <stat_bar name="vfspendingoperations"
-                    label="VFS Pending Operations"
-                    orientation="horizontal"
-                    stat="vfspendingoperations"
-                    unit_label=" Ops."
-                    show_bar="false"/>
 			  </stat_view>
 		  </stat_view>
 <!--Sim Stats-->
diff --git a/indra/newview/skins/default/xui/en/floater_snapshot.xml b/indra/newview/skins/default/xui/en/floater_snapshot.xml
index 832c2ee7da..f441e3cbd7 100644
--- a/indra/newview/skins/default/xui/en/floater_snapshot.xml
+++ b/indra/newview/skins/default/xui/en/floater_snapshot.xml
@@ -400,7 +400,7 @@
    layout="topleft"
    name="img_info_border"
    top_pad="0"
-   right="-10"
+   right="-130"
    follows="left|top|right"
    left_delta="0"/>
    <text
@@ -411,11 +411,10 @@
     height="14"
     layout="topleft"
     left="220"
-	right="-20"
     halign="left"
     name="image_res_text"
     top_delta="5"
-    width="200">
+    width="250">
        [WIDTH]px (width) x [HEIGHT]px (height)
    </text>
    <text
@@ -423,7 +422,7 @@
     font="SansSerifSmall"
     height="14"
     layout="topleft"
-    left="-65"
+    left="-185"
     length="1"
     halign="right"
     name="file_size_label"
@@ -432,4 +431,19 @@
     width="50">
        [SIZE] KB
    </text>
+   <text
+    follows="right|top"
+    font="SansSerifSmall"
+    height="14"
+    layout="topleft"
+    left="-130"
+    length="1"
+    halign="right"
+    name="360_label"
+    text_color="0.3 0.82 1 1"
+    top_delta="0"
+    type="string"
+    width="115">
+    Take a 360 snapshot
+   </text>
 </floater>
diff --git a/indra/newview/skins/default/xui/en/floater_stats.xml b/indra/newview/skins/default/xui/en/floater_stats.xml
index e4f735740b..f9d44b2c69 100644
--- a/indra/newview/skins/default/xui/en/floater_stats.xml
+++ b/indra/newview/skins/default/xui/en/floater_stats.xml
@@ -198,10 +198,6 @@
                     stat="messagedataout"
                     decimal_digits="1"
                     show_history="false"/>
-          <stat_bar name="vfspendingoperations"
-                    label="VFS Pending Operations"
-                    stat="vfspendingoperations"
-                    unit_label="Ops."/>
         </stat_view>
       </stat_view>
 
diff --git a/indra/newview/skins/default/xui/en/floater_toybox.xml b/indra/newview/skins/default/xui/en/floater_toybox.xml
index bc19d6e79f..bdc04a8a78 100644
--- a/indra/newview/skins/default/xui/en/floater_toybox.xml
+++ b/indra/newview/skins/default/xui/en/floater_toybox.xml
@@ -4,7 +4,7 @@
   can_dock="false"
   can_minimize="false"
   can_resize="false"
-  height="375"
+  height="430"
   help_topic="toybox"
   layout="topleft"
   legacy_header_height="18"
@@ -45,7 +45,7 @@
       Buttons will appear as shown or as icon-only depending on each toolbar's settings.
   </text>
   <toolbar
-    bottom="310"
+    bottom="365"
     button_display_mode="icons_with_text"
     follows="all"
     left="20"
@@ -81,11 +81,11 @@
   <panel
     bevel_style="none"
     border="true"
-    bottom="311"
+    bottom="366"
     follows="left|bottom|right"
     left="20"
     right="-20"
-    top="311" />
+    top="366" />
   <button
     follows="left|bottom|right"
     height="23"
@@ -94,7 +94,7 @@
     layout="topleft"
     left="185"
     name="btn_clear_all"
-    top="330"
+    top="385"
     width="130">
     <button.commit_callback function="Toybox.ClearAll" />
   </button>
@@ -106,7 +106,7 @@
     layout="topleft"
     left="335"
     name="btn_restore_defaults"
-    top="330"
+    top="385"
     width="130">
     <button.commit_callback function="Toybox.RestoreDefaults" />
   </button>
diff --git a/indra/newview/skins/default/xui/en/menu_viewer.xml b/indra/newview/skins/default/xui/en/menu_viewer.xml
index 4e174cc832..0336a0b763 100644
--- a/indra/newview/skins/default/xui/en/menu_viewer.xml
+++ b/indra/newview/skins/default/xui/en/menu_viewer.xml
@@ -732,6 +732,15 @@
              function="Floater.Show"
              parameter="snapshot" />
         </menu_item_call>
+        
+<menu_item_call
+         label="360 snapshot"
+         name="Capture 360"
+         shortcut="control|alt|shift|s">
+            <menu_item_call.on_click
+             function="Floater.Show"
+             parameter="360capture" />
+        </menu_item_call>
         <menu_item_separator/>
         <menu_item_call
          label="Place profile"
@@ -3426,6 +3435,14 @@ function="World.EnvPreset"
                 <menu_item_call.on_click
                  function="Advanced.DumpRegionObjectCache" />
             </menu_item_call>
+        
+<menu_item_call
+             label="Interest List: Full Update"
+             name="Interest List: Full Update"
+             shortcut="alt|shift|I">
+                <menu_item_call.on_click
+                 function="Advanced.InterestListFullUpdate" />
+            </menu_item_call>
         </menu>
         <menu
          create_jump_keys="true"
diff --git a/indra/newview/skins/default/xui/en/panel_preferences_chat.xml b/indra/newview/skins/default/xui/en/panel_preferences_chat.xml
index c023cb036e..35bd736d77 100644
--- a/indra/newview/skins/default/xui/en/panel_preferences_chat.xml
+++ b/indra/newview/skins/default/xui/en/panel_preferences_chat.xml
@@ -44,16 +44,6 @@
     <check_box
         enabled="false"
         height="16"
-        label="Email me IMs when I'm offline"
-        layout="topleft"
-        name="send_im_to_email"
-        top_pad="6"
-        width="330">
-    </check_box>
-
-    <check_box
-        enabled="false"
-        height="16"
         label="Only friends and groups can call or IM me"
         layout="topleft"
         name="voice_call_friends_only_check"
@@ -62,6 +52,20 @@
     </check_box>
 
     <text
+       font="SansSerifSmall"
+       height="16"
+       layout="topleft"
+       length="1"       
+       name="email_settings"
+       skip_link_underline="true"
+       top_pad="6"
+       left_delta="2"
+       type="string"
+       width="350">
+      [https://accounts.secondlife.com/change_email Email me IMs when I'm offline]
+    </text>
+
+    <text
         layout="topleft"
         left="345"
         height="12"
diff --git a/indra/newview/skins/default/xui/en/strings.xml b/indra/newview/skins/default/xui/en/strings.xml
index d115e09d5b..f26ee06e6b 100644
--- a/indra/newview/skins/default/xui/en/strings.xml
+++ b/indra/newview/skins/default/xui/en/strings.xml
@@ -17,7 +17,6 @@
 	<string name="StartupLoading">Loading [APP_NAME]...</string>
 	<string name="StartupClearingCache">Clearing cache...</string>
 	<string name="StartupInitializingTextureCache">Initializing texture cache...</string>
-	<string name="StartupInitializingVFS">Initializing VFS...</string>
 	<string name="StartupRequireDriverUpdate">Graphics initialization failed. Please update your graphics driver!</string>
 
 	<!-- about dialog/support string-->
@@ -56,9 +55,9 @@ LOD factor: [LOD_FACTOR]
 Render quality: [RENDER_QUALITY]
 Advanced Lighting Model: [GPU_SHADERS]
 Texture memory: [TEXTURE_MEMORY]MB
-VFS (cache) creation time: [VFS_TIME]
+Disk cache: [DISK_CACHE_INFO]
 	</string>
-	<string name="AboutOSXHiDPI">
+  <string name="AboutOSXHiDPI">
 HiDPI display mode: [HIDPI]
 	</string>
 	<string name="AboutLibs">
@@ -4124,6 +4123,8 @@ Try enclosing path to the editor with double quotes.
 
   <!-- commands -->
 
+  <string 
+name="Command_360_Capture_Label">360 snapshot</string>
   <string name="Command_AboutLand_Label">About land</string>
   <string name="Command_Appearance_Label">Outfits</string>
   <string name="Command_Avatar_Label">Complete avatars</string>
@@ -4154,6 +4155,8 @@ Try enclosing path to the editor with double quotes.
   <string name="Command_View_Label">Camera controls</string>
   <string name="Command_Voice_Label">Voice settings</string>
 
+  <string 
+name="Command_360_Capture_Tooltip">Capture a 360 equirectangular image</string>
   <string name="Command_AboutLand_Tooltip">Information about the land you're visiting</string>
   <string name="Command_Appearance_Tooltip">Change your avatar</string>
   <string name="Command_Avatar_Tooltip">Choose a complete avatar</string>
diff --git a/indra/newview/skins/default/xui/es/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/es/floater_scene_load_stats.xml
index f625d5257c..cfc5e524b5 100644
--- a/indra/newview/skins/default/xui/es/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/es/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
 					<stat_bar label="Capas" name="layersdatareceived"/>
 					<stat_bar label="Entrando ahora" name="messagedatain"/>
 					<stat_bar label="Saliendo ahora" name="messagedataout"/>
-					<stat_bar label="Operaciones VFS pendientes" name="vfspendingoperations"/>
 				</stat_view>
 			</stat_view>
 			<stat_view label="Simulador" name="sim">
diff --git a/indra/newview/skins/default/xui/es/floater_stats.xml b/indra/newview/skins/default/xui/es/floater_stats.xml
index d1c5e867db..0aec786f25 100644
--- a/indra/newview/skins/default/xui/es/floater_stats.xml
+++ b/indra/newview/skins/default/xui/es/floater_stats.xml
@@ -56,7 +56,6 @@
 					<stat_bar label="Capas" name="layersdatareceived"/>
 					<stat_bar label="Entrando ahora" name="messagedatain"/>
 					<stat_bar label="Saliendo ahora" name="messagedataout"/>
-					<stat_bar label="Operaciones VFS pendientes" name="vfspendingoperations"/>
 				</stat_view>
 			</stat_view>
 			<stat_view label="Simulador" name="sim">
diff --git a/indra/newview/skins/default/xui/es/strings.xml b/indra/newview/skins/default/xui/es/strings.xml
index f5e7d0bf4e..ebb4ceaa7e 100644
--- a/indra/newview/skins/default/xui/es/strings.xml
+++ b/indra/newview/skins/default/xui/es/strings.xml
@@ -22,9 +22,6 @@
 	<string name="StartupInitializingTextureCache">
 		Iniciando la caché de las texturas...
 	</string>
-	<string name="StartupInitializingVFS">
-		Iniciando VFS...
-	</string>
 	<string name="StartupRequireDriverUpdate">
 		Error de inicialización de gráficos. Actualiza tu controlador de gráficos.
 	</string>
@@ -65,7 +62,6 @@ Factor LOD: [LOD_FACTOR]
 Calidad de renderización: [RENDER_QUALITY]
 Modelo de iluminación avanzado: [GPU_SHADERS]
 Memoria de textura: [TEXTURE_MEMORY]MB
-VFS (cache) hora de creación: [VFS_TIME]
 	</string>
 	<string name="AboutOSXHiDPI">
 		Modo de visualización HiDPi: [HIDPI]
diff --git a/indra/newview/skins/default/xui/fr/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/fr/floater_scene_load_stats.xml
index 62830054bf..3889b13f0c 100644
--- a/indra/newview/skins/default/xui/fr/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/fr/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
 					<stat_bar label="Couches" name="layersdatareceived"/>
 					<stat_bar label="Arrivés" name="messagedatain"/>
 					<stat_bar label="Sortis" name="messagedataout"/>
-					<stat_bar label="Opérations VFS en attente" name="vfspendingoperations"/>
 				</stat_view>
 			</stat_view>
 			<stat_view label="Simulateur" name="sim">
diff --git a/indra/newview/skins/default/xui/fr/floater_stats.xml b/indra/newview/skins/default/xui/fr/floater_stats.xml
index fae17e3608..d0f7f42939 100644
--- a/indra/newview/skins/default/xui/fr/floater_stats.xml
+++ b/indra/newview/skins/default/xui/fr/floater_stats.xml
@@ -56,7 +56,6 @@
 					<stat_bar label="Couches" name="layersdatareceived"/>
 					<stat_bar label="Arrivés" name="messagedatain"/>
 					<stat_bar label="Sortis" name="messagedataout"/>
-					<stat_bar label="Opérations VFS en attente" name="vfspendingoperations"/>
 				</stat_view>
 			</stat_view>
 			<stat_view label="Simulateur" name="sim">
diff --git a/indra/newview/skins/default/xui/fr/strings.xml b/indra/newview/skins/default/xui/fr/strings.xml
index f26eac545a..9fde703d6c 100644
--- a/indra/newview/skins/default/xui/fr/strings.xml
+++ b/indra/newview/skins/default/xui/fr/strings.xml
@@ -31,9 +31,6 @@
 	<string name="StartupInitializingTextureCache">
 		Initialisation du cache des textures...
 	</string>
-	<string name="StartupInitializingVFS">
-		Initialisation VFS...
-	</string>
 	<string name="StartupRequireDriverUpdate">
 		Échec d&apos;initialisation des graphiques. Veuillez mettre votre pilote graphique à jour.
 	</string>
@@ -74,7 +71,6 @@ Facteur LOD (niveau de détail) : [LOD_FACTOR]
 Qualité de rendu : [RENDER_QUALITY]
 Modèle d’éclairage avancé : [GPU_SHADERS]
 Mémoire textures : [TEXTURE_MEMORY] Mo
-Heure de création VFS (cache) : [VFS_TIME]
 	</string>
 	<string name="AboutOSXHiDPI">
 		Mode d&apos;affichage HiDPI : [HIDPI]
diff --git a/indra/newview/skins/default/xui/it/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/it/floater_scene_load_stats.xml
index ca18812eb7..efceb05298 100644
--- a/indra/newview/skins/default/xui/it/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/it/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
 					<stat_bar label="Livelli" name="layersdatareceived"/>
 					<stat_bar label="Effettivi in ingresso" name="messagedatain"/>
 					<stat_bar label="Effettivi in uscita" name="messagedataout"/>
-					<stat_bar label="Operazioni VFS in sospeso" name="vfspendingoperations"/>
 				</stat_view>
 			</stat_view>
 			<stat_view label="Simulatore" name="sim">
diff --git a/indra/newview/skins/default/xui/it/floater_stats.xml b/indra/newview/skins/default/xui/it/floater_stats.xml
index 7ef13aa37f..6434c3b66b 100644
--- a/indra/newview/skins/default/xui/it/floater_stats.xml
+++ b/indra/newview/skins/default/xui/it/floater_stats.xml
@@ -56,7 +56,6 @@
 					<stat_bar label="Livelli" name="layersdatareceived"/>
 					<stat_bar label="Effettivi in ingresso" name="messagedatain"/>
 					<stat_bar label="Effettivi in uscita" name="messagedataout"/>
-					<stat_bar label="Operazioni VFS in sospeso" name="vfspendingoperations"/>
 				</stat_view>
 			</stat_view>
 			<stat_view label="Simulatore" name="sim">
diff --git a/indra/newview/skins/default/xui/it/strings.xml b/indra/newview/skins/default/xui/it/strings.xml
index f0466cea81..3049828f46 100644
--- a/indra/newview/skins/default/xui/it/strings.xml
+++ b/indra/newview/skins/default/xui/it/strings.xml
@@ -28,9 +28,6 @@
 	<string name="StartupInitializingTextureCache">
 		Inizializzazione della cache texture...
 	</string>
-	<string name="StartupInitializingVFS">
-		Inizializzazione VFS...
-	</string>
 	<string name="StartupRequireDriverUpdate">
 		Inizializzazione grafica non riuscita. Aggiorna il driver della scheda grafica!
 	</string>
@@ -71,7 +68,6 @@ Fattore livello di dettaglio: [LOD_FACTOR]
 Qualità di rendering: [RENDER_QUALITY]
 Modello illuminazione avanzato: [GPU_SHADERS]
 Memoria texture: [TEXTURE_MEMORY]MB
-Data/ora creazione VFS (cache): [VFS_TIME]
 	</string>
 	<string name="AboutOSXHiDPI">
 		Modalità display HiDPI: [HIDPI]
diff --git a/indra/newview/skins/default/xui/ja/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/ja/floater_scene_load_stats.xml
index f6edce026f..f348ce3c4d 100644
--- a/indra/newview/skins/default/xui/ja/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/ja/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
 					<stat_bar label="レイヤー" name="layersdatareceived"/>
 					<stat_bar label="実際の受信" name="messagedatain"/>
 					<stat_bar label="実際の送信" name="messagedataout"/>
-					<stat_bar label="VFS 保留中の操作" name="vfspendingoperations"/>
 				</stat_view>
 			</stat_view>
 			<stat_view label="シミュレーター" name="sim">
diff --git a/indra/newview/skins/default/xui/ja/floater_stats.xml b/indra/newview/skins/default/xui/ja/floater_stats.xml
index 3bc343639b..1da0e5ebc9 100644
--- a/indra/newview/skins/default/xui/ja/floater_stats.xml
+++ b/indra/newview/skins/default/xui/ja/floater_stats.xml
@@ -56,7 +56,6 @@
 					<stat_bar label="レイヤー" name="layersdatareceived"/>
 					<stat_bar label="実際の受信" name="messagedatain"/>
 					<stat_bar label="実際の送信" name="messagedataout"/>
-					<stat_bar label="VFS 保留中の操作" name="vfspendingoperations"/>
 				</stat_view>
 			</stat_view>
 			<stat_view label="シミュレーター" name="sim">
diff --git a/indra/newview/skins/default/xui/ja/strings.xml b/indra/newview/skins/default/xui/ja/strings.xml
index 52d6fb0c2b..dcd6e65d34 100644
--- a/indra/newview/skins/default/xui/ja/strings.xml
+++ b/indra/newview/skins/default/xui/ja/strings.xml
@@ -31,9 +31,6 @@
 	<string name="StartupInitializingTextureCache">
 		テクスチャキャッシュを初期化中です...
 	</string>
-	<string name="StartupInitializingVFS">
-		VFS を初期化中です...
-	</string>
 	<string name="StartupRequireDriverUpdate">
 		グラフィックを初期化できませんでした。グラフィックドライバを更新してください。
 	</string>
@@ -74,7 +71,6 @@ LOD 係数: [LOD_FACTOR]
 描画の質: [RENDER_QUALITY]
 高度なライティングモデル: [GPU_SHADERS]
 テクスチャメモリ: [TEXTURE_MEMORY]MB
-VFS（キャッシュ）作成時間: [VFS_TIME]
 	</string>
 	<string name="AboutOSXHiDPI">
 		HiDPI 表示モード: [HIDPI]
diff --git a/indra/newview/skins/default/xui/pl/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/pl/floater_scene_load_stats.xml
index 6fdc7e19f6..8f5d0c5c70 100644
--- a/indra/newview/skins/default/xui/pl/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/pl/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
 					<stat_bar name="layersdatareceived" label="Warstwy" />
 					<stat_bar name="messagedatain" label="Aktualna il. wchodząca" />
 					<stat_bar name="messagedataout" label="Aktualna il. wychodząca" />
-					<stat_bar name="vfspendingoperations" label="Operacje oczekujące VFS" unit_label=" op." />
 				</stat_view>
 			</stat_view>
 			<stat_view name="sim" label="Symulator">
diff --git a/indra/newview/skins/default/xui/pl/floater_stats.xml b/indra/newview/skins/default/xui/pl/floater_stats.xml
index 5dd7d19bab..21e37717c2 100644
--- a/indra/newview/skins/default/xui/pl/floater_stats.xml
+++ b/indra/newview/skins/default/xui/pl/floater_stats.xml
@@ -55,7 +55,6 @@
 					<stat_bar label="Warstwy" name="layersdatareceived" />
 					<stat_bar label="Aktualna il. wchodząca" name="messagedatain" />
 					<stat_bar label="Aktualna il. wychodząca" name="messagedataout" />
-					<stat_bar label="Operacje oczekujące VFS" name="vfspendingoperations" />
 				</stat_view>
 			</stat_view>
 			<stat_view label="Symulator" name="sim">
diff --git a/indra/newview/skins/default/xui/pl/strings.xml b/indra/newview/skins/default/xui/pl/strings.xml
index 91fea234d2..cf033df3c9 100644
--- a/indra/newview/skins/default/xui/pl/strings.xml
+++ b/indra/newview/skins/default/xui/pl/strings.xml
@@ -15,9 +15,6 @@
 	<string name="StartupInitializingTextureCache">
 		Inicjowanie bufora danych tekstur...
 	</string>
-	<string name="StartupInitializingVFS">
-		Inicjowanie wirtualnego systemu plików...
-	</string>
 	<string name="StartupRequireDriverUpdate">
 		Nie można zainicjować grafiki. Zaktualizuj sterowniki!
 	</string>
diff --git a/indra/newview/skins/default/xui/pt/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/pt/floater_scene_load_stats.xml
index 027e1ef311..dbaab1d782 100644
--- a/indra/newview/skins/default/xui/pt/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/pt/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
 					<stat_bar label="Layers" name="layersdatareceived"/>
 					<stat_bar label="Actual In" name="messagedatain"/>
 					<stat_bar label="Actual Out" name="messagedataout"/>
-					<stat_bar label="Operações pendentes do VFS" name="vfspendingoperations"/>
 				</stat_view>
 			</stat_view>
 			<stat_view label="Simulator" name="sim">
diff --git a/indra/newview/skins/default/xui/pt/floater_stats.xml b/indra/newview/skins/default/xui/pt/floater_stats.xml
index f41fe17778..3253984268 100644
--- a/indra/newview/skins/default/xui/pt/floater_stats.xml
+++ b/indra/newview/skins/default/xui/pt/floater_stats.xml
@@ -56,7 +56,6 @@
 					<stat_bar label="Layers" name="layersdatareceived"/>
 					<stat_bar label="Actual In" name="messagedatain"/>
 					<stat_bar label="Actual Out" name="messagedataout"/>
-					<stat_bar label="Operações pendentes do VFS" name="vfspendingoperations"/>
 				</stat_view>
 			</stat_view>
 			<stat_view label="Simulator" name="sim">
diff --git a/indra/newview/skins/default/xui/pt/strings.xml b/indra/newview/skins/default/xui/pt/strings.xml
index ee982b5b22..c72a41fd3a 100644
--- a/indra/newview/skins/default/xui/pt/strings.xml
+++ b/indra/newview/skins/default/xui/pt/strings.xml
@@ -22,9 +22,6 @@
 	<string name="StartupInitializingTextureCache">
 		Iniciando cache de texturas...
 	</string>
-	<string name="StartupInitializingVFS">
-		Iniciando VFS...
-	</string>
 	<string name="StartupRequireDriverUpdate">
 		Falha na inicialização dos gráficos. Atualize seu driver gráfico!
 	</string>
@@ -65,7 +62,6 @@ LOD fator: [LOD_FACTOR]
 Qualidade de renderização: [RENDER_QUALITY]
 Modelo avançado de luzes: [GPU_SHADERS]
 Memória de textura: [TEXTURE_MEMORY]MB
-VFS (cache) tempo de criação: [VFS_TIME]
 	</string>
 	<string name="AboutOSXHiDPI">
 		HiDPI modo de exibição: [HIDPI]
diff --git a/indra/newview/skins/default/xui/ru/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/ru/floater_scene_load_stats.xml
index a101e62627..c4f432023c 100644
--- a/indra/newview/skins/default/xui/ru/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/ru/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
 					<stat_bar label="Слои" name="layersdatareceived"/>
 					<stat_bar label="Действительный ввод" name="messagedatain"/>
 					<stat_bar label="Действительный вывод" name="messagedataout"/>
-					<stat_bar label="Ожидающие операции VFS" name="vfspendingoperations"/>
 				</stat_view>
 			</stat_view>
 			<stat_view label="Симулятор" name="sim">
diff --git a/indra/newview/skins/default/xui/ru/floater_stats.xml b/indra/newview/skins/default/xui/ru/floater_stats.xml
index 10e9f5a7f4..a7d26029c2 100644
--- a/indra/newview/skins/default/xui/ru/floater_stats.xml
+++ b/indra/newview/skins/default/xui/ru/floater_stats.xml
@@ -56,7 +56,6 @@
 					<stat_bar label="Слои" name="layersdatareceived"/>
 					<stat_bar label="Действительный ввод" name="messagedatain"/>
 					<stat_bar label="Действительный вывод" name="messagedataout"/>
-					<stat_bar label="Ожидающие операции VFS" name="vfspendingoperations"/>
 				</stat_view>
 			</stat_view>
 			<stat_view label="Симулятор" name="sim">
diff --git a/indra/newview/skins/default/xui/ru/strings.xml b/indra/newview/skins/default/xui/ru/strings.xml
index e9592a0476..43a87b2b18 100644
--- a/indra/newview/skins/default/xui/ru/strings.xml
+++ b/indra/newview/skins/default/xui/ru/strings.xml
@@ -31,9 +31,6 @@
 	<string name="StartupInitializingTextureCache">
 		Инициализация кэша текстур...
 	</string>
-	<string name="StartupInitializingVFS">
-		Инициализация виртуальной файловой системы...
-	</string>
 	<string name="StartupRequireDriverUpdate">
 		Ошибка инициализации графики. Обновите графический драйвер!
 	</string>
@@ -74,7 +71,6 @@ SLURL: &lt;nolink&gt;[SLURL]&lt;/nolink&gt;
 Качество визуализации: [RENDER_QUALITY]
 Расширенная модель освещения: [GPU_SHADERS]
 Память текстур: [TEXTURE_MEMORY] МБ
-Время создания VFS (кэш): [VFS_TIME]
 	</string>
 	<string name="AboutOSXHiDPI">
 		Режим отображения HiDPI: [HIDPI]
diff --git a/indra/newview/skins/default/xui/tr/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/tr/floater_scene_load_stats.xml
index ae0a94595d..7d5f4adb02 100644
--- a/indra/newview/skins/default/xui/tr/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/tr/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
 					<stat_bar label="Katmanlar" name="layersdatareceived"/>
 					<stat_bar label="Gerçekte Gelen" name="messagedatain"/>
 					<stat_bar label="Gerçekte Giden" name="messagedataout"/>
-					<stat_bar label="VFS Bekleyen İşlemler" name="vfspendingoperations"/>
 				</stat_view>
 			</stat_view>
 			<stat_view label="Simülatör" name="sim">
diff --git a/indra/newview/skins/default/xui/tr/floater_stats.xml b/indra/newview/skins/default/xui/tr/floater_stats.xml
index 1ae42ad382..bd36d4916f 100644
--- a/indra/newview/skins/default/xui/tr/floater_stats.xml
+++ b/indra/newview/skins/default/xui/tr/floater_stats.xml
@@ -56,7 +56,6 @@
 					<stat_bar label="Katmanlar" name="layersdatareceived"/>
 					<stat_bar label="Gerçekte Gelen" name="messagedatain"/>
 					<stat_bar label="Gerçekte Giden" name="messagedataout"/>
-					<stat_bar label="VFS Bekleyen İşlemler" name="vfspendingoperations"/>
 				</stat_view>
 			</stat_view>
 			<stat_view label="Simülatör" name="sim">
diff --git a/indra/newview/skins/default/xui/tr/strings.xml b/indra/newview/skins/default/xui/tr/strings.xml
index 56fad978f5..982de76a5b 100644
--- a/indra/newview/skins/default/xui/tr/strings.xml
+++ b/indra/newview/skins/default/xui/tr/strings.xml
@@ -31,9 +31,6 @@
 	<string name="StartupInitializingTextureCache">
 		Doku önbelleği başlatılıyor...
 	</string>
-	<string name="StartupInitializingVFS">
-		VFS Başlatılıyor...
-	</string>
 	<string name="StartupRequireDriverUpdate">
 		Grafik başlatma başarılamadı. Lütfen grafik sürücünüzü güncelleştirin!
 	</string>
@@ -74,7 +71,6 @@ LOD faktörü: [LOD_FACTOR]
 İşleme kalitesi: [RENDER_QUALITY]
 Gelişmiş Aydınlatma Modeli: [GPU_SHADERS]
 Doku belleği: [TEXTURE_MEMORY]MB
-VFS (önbellek) oluşturma saati: [VFS_TIME]
 	</string>
 	<string name="AboutOSXHiDPI">
 		HiDPI görüntü modu: [HIDPI]
diff --git a/indra/newview/skins/default/xui/zh/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/zh/floater_scene_load_stats.xml
index 1a5c20abeb..20344e299f 100644
--- a/indra/newview/skins/default/xui/zh/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/zh/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
 					<stat_bar label="層次" name="layersdatareceived"/>
 					<stat_bar label="實入" name="messagedatain"/>
 					<stat_bar label="實出" name="messagedataout"/>
-					<stat_bar label="VFS 待行作業" name="vfspendingoperations"/>
 				</stat_view>
 			</stat_view>
 			<stat_view label="模擬器" name="sim">
diff --git a/indra/newview/skins/default/xui/zh/floater_stats.xml b/indra/newview/skins/default/xui/zh/floater_stats.xml
index f06eb5e78f..e233ece527 100644
--- a/indra/newview/skins/default/xui/zh/floater_stats.xml
+++ b/indra/newview/skins/default/xui/zh/floater_stats.xml
@@ -56,7 +56,6 @@
 					<stat_bar label="層次" name="layersdatareceived"/>
 					<stat_bar label="實入" name="messagedatain"/>
 					<stat_bar label="實出" name="messagedataout"/>
-					<stat_bar label="VFS 待行作業" name="vfspendingoperations"/>
 				</stat_view>
 			</stat_view>
 			<stat_view label="模擬器" name="sim">
diff --git a/indra/newview/skins/default/xui/zh/strings.xml b/indra/newview/skins/default/xui/zh/strings.xml
index e6c61a5d94..3221cde3b7 100644
--- a/indra/newview/skins/default/xui/zh/strings.xml
+++ b/indra/newview/skins/default/xui/zh/strings.xml
@@ -31,9 +31,6 @@
 	<string name="StartupInitializingTextureCache">
 		正在初始化材質快取...
 	</string>
-	<string name="StartupInitializingVFS">
-		VFS 初始化中...
-	</string>
 	<string name="StartupRequireDriverUpdate">
 		顯像初始化失敗。 請更新你的顯像卡驅動程式！
 	</string>
@@ -74,7 +71,6 @@
 呈像品質：[RENDER_QUALITY]
 進階照明模型：[GPU_SHADERS]
 材質記憶體：[TEXTURE_MEMORY]MB
-VFS（快取）建立時間：[VFS_TIME]
 	</string>
 	<string name="AboutOSXHiDPI">
 		HiDPI顯示模式：[HIDPI]
diff --git a/indra/newview/viewer_manifest.py b/indra/newview/viewer_manifest.py
index 6fcd1e84e8..a814bd2849 100755
--- a/indra/newview/viewer_manifest.py
+++ b/indra/newview/viewer_manifest.py
@@ -69,7 +69,6 @@ class ViewerManifest(LLManifest):
                 self.exclude("logcontrol-dev.xml")
                 self.path("*.ini")
                 self.path("*.xml")
-                self.path("*.db2")
 
                 # include the entire shaders directory recursively
                 self.path("shaders")
@@ -158,18 +157,12 @@ class ViewerManifest(LLManifest):
                     self.path("*/xui/*/widgets/*.xml")
                     self.path("*/*.xml")
 
-                    # Local HTML files (e.g. loading screen)
-                    # The claim is that we never use local html files any
-                    # longer. But rather than commenting out this block, let's
-                    # rename every html subdirectory as html.old. That way, if
-                    # we're wrong, a user actually does have the relevant
-                    # files; s/he just needs to rename every html.old
-                    # directory back to html to recover them.
-                    with self.prefix(src="*/html", dst="*/html.old"):
-                            self.path("*.png")
-                            self.path("*/*/*.html")
-                            self.path("*/*/*.gif")
-
+                    # Update: 2017-11-01 CP Now we store app code in the html folder
+                    #         Initially the HTML/JS code to render equirectangular
+                    #         images for the 360 capture feature but more to follow.
+                    with self.prefix(src="*/html", dst="*/html"):
+                        self.path("*/*/*/*.js")
+                        self.path("*/*/*.html")
 
             #build_data.json.  Standard with exception handling is fine.  If we can't open a new file for writing, we have worse problems
             #platform is computed above with other arg parsing
diff --git a/indra/test/CMakeLists.txt b/indra/test/CMakeLists.txt
index 251100867f..084aa8d9f7 100644
--- a/indra/test/CMakeLists.txt
+++ b/indra/test/CMakeLists.txt
@@ -8,7 +8,7 @@ include(LLCoreHttp)
 include(LLInventory)
 include(LLMath)
 include(LLMessage)
-include(LLVFS)
+include(LLFileSystem)
 include(LLXML)
 include(Linking)
 include(Tut)
@@ -23,7 +23,7 @@ include_directories(
     ${LLMATH_INCLUDE_DIRS}
     ${LLMESSAGE_INCLUDE_DIRS}
     ${LLINVENTORY_INCLUDE_DIRS}
-    ${LLVFS_INCLUDE_DIRS}
+    ${LLFILESYSTEM_INCLUDE_DIRS}
     ${LLXML_INCLUDE_DIRS}
     ${LSCRIPT_INCLUDE_DIRS}
     ${GOOGLEMOCK_INCLUDE_DIRS}
@@ -93,7 +93,7 @@ target_link_libraries(lltest
     ${LLINVENTORY_LIBRARIES}
     ${LLMESSAGE_LIBRARIES}
     ${LLMATH_LIBRARIES}
-    ${LLVFS_LIBRARIES}
+    ${LLFILESYSTEM_LIBRARIES}
     ${LLXML_LIBRARIES}
     ${LSCRIPT_LIBRARIES}
     ${LLCOMMON_LIBRARIES}