Merge RLVa SSB update

2013-02-24 18:24:48 -08:00 · 2013-02-24 18:24:48 -08:00 · 6425b3cd65
parent 6207030884 4101c43f5f
commit 6425b3cd65
95 changed files with 3748 additions and 770 deletions
--- a/.hgignore
+++ b/.hgignore
@ -86,6 +86,7 @@ glob:indra/newview/filters.xml
 glob:indra/newview/avatar_icons_cache.txt
 glob:indra/newview/avatar_lad.log
 glob:*.diff
+#*.rej
 glob:fmod*
 syntax: regexp
 ^indra/build
--- a/.hgpatchinfo/.RLVa.dep
+++ b/.hgpatchinfo/.RLVa.dep
@ -1,2 +1,2 @@
-db4f80bf75c83fa193d361f84f3dfca39b045adb
-72265032c8e13ebdb9e2b4a80b10e9e804ef9a63
+42a8488a18e787a7e801671a4a522d2383484ddd
+bc935b340692666dc2e1dc528f125832ac1095a3
--- a/.hgpatchinfo/Appearance-Misc.dep
+++ b/.hgpatchinfo/Appearance-Misc.dep
@ -1 +1 @@
-3dc93871abf9684a136736abce64f3c1f990fb18
+033229d48fcb4b8e62f23369b3cbb7821905c691
--- a/.hgpatchinfo/Appearance-MixedViewers.dep
+++ b/.hgpatchinfo/Appearance-MixedViewers.dep
@ -1 +1 @@
-3dc93871abf9684a136736abce64f3c1f990fb18
+033229d48fcb4b8e62f23369b3cbb7821905c691
--- a/.hgpatchinfo/Viewer-Build.dep
+++ b/.hgpatchinfo/Viewer-Build.dep
@ -1 +1 @@
-bd1162cb6fbe7dc5a65d0de8fa56b9958b40b45d
+87a6fc812214b9f4c52fdf6337c202e084e3af91
--- a/.hgtags
+++ b/.hgtags
@ -452,3 +452,475 @@ b23419a2748483c98f3b84b630468a21c88feba5 DRTVWR-292
 0a5d409161ef2a89b28c9a741051dd2dedc707d6 DRTVWR-297
 852b69ef0b5fe6b13b69cc2217282cc64de6afab 3.4.5-beta5
 a49c715243a36a8a380504d14cb7416b3039c956 3.4.5-release
+0000000000000000000000000000000000000000 alpha-3
+0000000000000000000000000000000000000000 fork to viewer-2-0
+0000000000000000000000000000000000000000 alpha-4
+0000000000000000000000000000000000000000 fork to viewer-20qa
+0000000000000000000000000000000000000000 alpha-5
+0000000000000000000000000000000000000000 howard-demo
+0000000000000000000000000000000000000000 alpha-6
+0000000000000000000000000000000000000000 beta-3-5
+0000000000000000000000000000000000000000 beta-4
+0000000000000000000000000000000000000000 beta-5
+0000000000000000000000000000000000000000 viewer-2-0-0
+0000000000000000000000000000000000000000 viewer-2-0-1
+0000000000000000000000000000000000000000 2-1rn1
+0000000000000000000000000000000000000000 viewer-2-0-2-start
+0000000000000000000000000000000000000000 viewer-2-1-0-start
+0000000000000000000000000000000000000000 2-1-beta-1
+0000000000000000000000000000000000000000 2-1-beta-2
+0000000000000000000000000000000000000000 2-1-beta-3
+0000000000000000000000000000000000000000 2-1-beta-4
+0000000000000000000000000000000000000000 2-1-release
+0000000000000000000000000000000000000000 2-1-1-beta-1
+0000000000000000000000000000000000000000 2-1-1-beta-2
+0000000000000000000000000000000000000000 2-1-1-release
+0000000000000000000000000000000000000000 2.1.1-release
+0000000000000000000000000000000000000000 last_sprint
+0000000000000000000000000000000000000000 2.2.0-beta1
+0000000000000000000000000000000000000000 DRTVWR-5_2.2.0-beta1
+0000000000000000000000000000000000000000 beta_2.1.3
+0000000000000000000000000000000000000000 2.2.0-beta2
+0000000000000000000000000000000000000000 DRTVWR-3_2.2.0-beta2
+0000000000000000000000000000000000000000 2.2.0-beta3
+0000000000000000000000000000000000000000 DRTVWR-7_2.2.0-beta3
+0000000000000000000000000000000000000000 2.2.0-beta4
+0000000000000000000000000000000000000000 2.2.0-release
+0000000000000000000000000000000000000000 DRTVWR-8_2.2.0-release
+0000000000000000000000000000000000000000 2.3.0-start
+0000000000000000000000000000000000000000 2.3.0-beta1
+0000000000000000000000000000000000000000 DRTVWR-14_2.3.0-beta1
+0000000000000000000000000000000000000000 2.3.0-beta2
+0000000000000000000000000000000000000000 DRTVWR-17_2.3.0-beta2
+0000000000000000000000000000000000000000 2.3.0-beta3
+0000000000000000000000000000000000000000 2.3.0-release
+0000000000000000000000000000000000000000 DRTVWR-13_2.3.0-release
+0000000000000000000000000000000000000000 DRTVWR-20_2.3.0-beta3
+0000000000000000000000000000000000000000 2.4.0-start
+0000000000000000000000000000000000000000 2.4.0-beta1
+0000000000000000000000000000000000000000 DRTVWR-26_2.4.0-beta1
+0000000000000000000000000000000000000000 2.4.0-beta2
+0000000000000000000000000000000000000000 DRTVWR-27_2.4.0-beta2
+0000000000000000000000000000000000000000 2.4.0-release
+0000000000000000000000000000000000000000 DRTVWR-25_2.4.0-release
+0000000000000000000000000000000000000000 2.5.0-start
+0000000000000000000000000000000000000000 2.5.0-beta1
+0000000000000000000000000000000000000000 DRTVWR-32_2.5.0-beta1
+0000000000000000000000000000000000000000 2.5.0-beta2
+0000000000000000000000000000000000000000 DRTVWR-33--2.5.0beta2
+0000000000000000000000000000000000000000 DRTVWR-33_2.5.0-beta2
+0000000000000000000000000000000000000000 2.5.0-beta3
+0000000000000000000000000000000000000000 2.5.0-release
+0000000000000000000000000000000000000000 DRTVWR-31_2.5.0-release
+0000000000000000000000000000000000000000 DRTVWR-34_2.5.0-beta3
+0000000000000000000000000000000000000000 nat-eventapi2-base
+0000000000000000000000000000000000000000 2.5.1-start
+0000000000000000000000000000000000000000 2.5.1-release
+0000000000000000000000000000000000000000 DRTVWR-37_2.5.1-release
+0000000000000000000000000000000000000000 2.5.2-release
+0000000000000000000000000000000000000000 DRTVWR-38_2.5.2-release
+0000000000000000000000000000000000000000 2.6.0-start
+0000000000000000000000000000000000000000 2.6.0-beta1
+0000000000000000000000000000000000000000 DRTVWR-40_2.6.0-beta1
+0000000000000000000000000000000000000000 2.6.0-beta1-tip
+0000000000000000000000000000000000000000 2.6.0-beta2
+0000000000000000000000000000000000000000 DRTVWR-41_2.6.0-beta2
+0000000000000000000000000000000000000000 2.6.1-beta1
+0000000000000000000000000000000000000000 2.6.1-start
+0000000000000000000000000000000000000000 DRTVWR-43_2.6.1-beta1
+0000000000000000000000000000000000000000 2.6.2-start
+0000000000000000000000000000000000000000 2.6.2-beta1
+0000000000000000000000000000000000000000 DRTVWR-45_2.6.2-beta1
+0000000000000000000000000000000000000000 2.6.0-release
+0000000000000000000000000000000000000000 DRTVWR-39_2.6.0-release
+0000000000000000000000000000000000000000 2.6.1-release
+0000000000000000000000000000000000000000 DRTVWR-42_2.6.1-release
+0000000000000000000000000000000000000000 end-of-develop.py
+0000000000000000000000000000000000000000 2.6.3-start
+0000000000000000000000000000000000000000 2.6.3-beta1
+0000000000000000000000000000000000000000 DRTVWR-47_2.6.3-beta1
+0000000000000000000000000000000000000000 2.6.3-beta2
+0000000000000000000000000000000000000000 DRTVWR-48_2.6.3-beta2
+0000000000000000000000000000000000000000 dons-headless-hackathon-work
+0000000000000000000000000000000000000000 2.6.2-release
+0000000000000000000000000000000000000000 DRTVWR-44_2.6.2-release
+0000000000000000000000000000000000000000 2.6.5-beta1
+0000000000000000000000000000000000000000 DRTVWR-50_2.6.5-beta1
+0000000000000000000000000000000000000000 2.6.3-release
+0000000000000000000000000000000000000000 DRTVWR-46_2.6.3-release
+0000000000000000000000000000000000000000 2.6.6-start
+0000000000000000000000000000000000000000 2.6.6-beta1
+0000000000000000000000000000000000000000 DRTVWR-52_2.6.6-beta1
+0000000000000000000000000000000000000000 2.6.8-start
+0000000000000000000000000000000000000000 2.6.6-release
+0000000000000000000000000000000000000000 DRTVWR-51_2.6.6-release
+0000000000000000000000000000000000000000 2.6.8-beta1
+0000000000000000000000000000000000000000 DRTVWR-55_2.6.8-beta1
+0000000000000000000000000000000000000000 2.6.8-release
+0000000000000000000000000000000000000000 DRTVWR-54_2.6.8-release
+0000000000000000000000000000000000000000 2.6.9-start
+0000000000000000000000000000000000000000 2.6.9-beta1
+0000000000000000000000000000000000000000 2.6.9-release
+0000000000000000000000000000000000000000 DRTVWR-56_2.6.9-release
+0000000000000000000000000000000000000000 DRTVWR-57_2.6.9-beta1
+0000000000000000000000000000000000000000 2.7.0-start
+0000000000000000000000000000000000000000 2.7.0-beta1
+0000000000000000000000000000000000000000 DRTVWR-59_2.7.0-beta1
+0000000000000000000000000000000000000000 2.7.1-start
+0000000000000000000000000000000000000000 2.7.1-beta1
+0000000000000000000000000000000000000000 DRTVWR-61_2.7.1-beta1
+0000000000000000000000000000000000000000 2.7.2-start
+0000000000000000000000000000000000000000 2.7.2-beta1
+0000000000000000000000000000000000000000 DRTVWR-63_2.7.2-beta1
+0000000000000000000000000000000000000000 2.7.3-start
+0000000000000000000000000000000000000000 2.7.1-release
+0000000000000000000000000000000000000000 2.7.2-release
+0000000000000000000000000000000000000000 DRTVWR-60_2.7.1-release
+0000000000000000000000000000000000000000 DRTVWR-62_2.7.2-release
+0000000000000000000000000000000000000000 2.7.4-start
+0000000000000000000000000000000000000000 2.7.4-beta1
+0000000000000000000000000000000000000000 DRTVWR-67_2.7.4-beta1
+0000000000000000000000000000000000000000 2.7.5-start
+0000000000000000000000000000000000000000 2.7.5-beta1
+0000000000000000000000000000000000000000 DRTVWR-69_2.7.5-beta1
+0000000000000000000000000000000000000000 2.8.0-beta1
+0000000000000000000000000000000000000000 2.8.0-start
+0000000000000000000000000000000000000000 DRTVWR-71_2.8.0-beta1
+0000000000000000000000000000000000000000 2.7.4-release
+0000000000000000000000000000000000000000 DRTVWR-66_2.7.4-release
+0000000000000000000000000000000000000000 2.7.5-release
+0000000000000000000000000000000000000000 DRTVWR-68_2.7.5-release
+0000000000000000000000000000000000000000 2.8.1-start
+0000000000000000000000000000000000000000 2.8.1-beta1
+0000000000000000000000000000000000000000 DRTVWR-73_2.8.1-beta1
+0000000000000000000000000000000000000000 2.8.0-release
+0000000000000000000000000000000000000000 DRTVWR-70_2.8.0-release
+0000000000000000000000000000000000000000 2.8.2-start
+0000000000000000000000000000000000000000 2.8.3-start
+0000000000000000000000000000000000000000 2.8.1-release
+0000000000000000000000000000000000000000 DRTVWR-72_2.8.1-release
+0000000000000000000000000000000000000000 2.8.1-hotfix
+0000000000000000000000000000000000000000 DRTVWR-76_2.8.1-hotfix
+0000000000000000000000000000000000000000 2.8.3-beta1
+0000000000000000000000000000000000000000 DRTVWR-75_2.8.3-beta1
+0000000000000000000000000000000000000000 3.0.0-start
+0000000000000000000000000000000000000000 3.0.0-beta1
+0000000000000000000000000000000000000000 DRTVWR-78_3.0.0-beta1
+0000000000000000000000000000000000000000 2.8.3-release
+0000000000000000000000000000000000000000 DRTVWR-74_2.8.3-release
+0000000000000000000000000000000000000000 3.0.1-start
+0000000000000000000000000000000000000000 3.0.1-beta1
+0000000000000000000000000000000000000000 DRTVWR-81_3.0.1-beta1
+0000000000000000000000000000000000000000 3.0.2-start
+0000000000000000000000000000000000000000 3.0.2-beta1
+0000000000000000000000000000000000000000 DRTVWR-83_3.0.2-beta1
+0000000000000000000000000000000000000000 3.0.0-release
+0000000000000000000000000000000000000000 DRTVWR-77_3.0.0-release
+0000000000000000000000000000000000000000 3.0.2-beta2
+0000000000000000000000000000000000000000 DRTVWR-86_3.0.2-beta2
+0000000000000000000000000000000000000000 3.0.3-start
+0000000000000000000000000000000000000000 3.0.3-beta1
+0000000000000000000000000000000000000000 DRTVWR-85_3.0.3-beta1
+0000000000000000000000000000000000000000 3.0.3-beta2
+0000000000000000000000000000000000000000 DRTVWR-89_3.0.3-beta2
+0000000000000000000000000000000000000000 3.0.4-start
+0000000000000000000000000000000000000000 3.0.3-release
+0000000000000000000000000000000000000000 DRTVWR-84_3.0.3-release
+0000000000000000000000000000000000000000 3.0.5-start
+0000000000000000000000000000000000000000 3.1.0-start
+0000000000000000000000000000000000000000 3.1.0-beta1
+0000000000000000000000000000000000000000 DRTVWR-93_3.1.0-beta1
+0000000000000000000000000000000000000000 3.1.0-beta2
+0000000000000000000000000000000000000000 DRTVWR-96_3.1.0-beta2
+0000000000000000000000000000000000000000 3.1.0-release
+0000000000000000000000000000000000000000 DRTVWR-92_3.1.0-release
+0000000000000000000000000000000000000000 3.2.0-start
+0000000000000000000000000000000000000000 3.2.0-beta1
+0000000000000000000000000000000000000000 DRTVWR-95_3.2.0-beta1
+0000000000000000000000000000000000000000 3.2.0-beta2
+0000000000000000000000000000000000000000 DRTVWR-97_3.2.0-beta2
+0000000000000000000000000000000000000000 3.2.0-beta3
+0000000000000000000000000000000000000000 DRTVWR-98_3.2.0-beta3
+0000000000000000000000000000000000000000 3.2.0-release
+0000000000000000000000000000000000000000 DRTVWR-94_3.2.0-release
+0000000000000000000000000000000000000000 3.2.1-start
+0000000000000000000000000000000000000000 3.2.1-beta1
+0000000000000000000000000000000000000000 DRTVWR-100_3.2.1-beta1
+0000000000000000000000000000000000000000 3.2.2-start
+0000000000000000000000000000000000000000 3.2.2-beta1
+0000000000000000000000000000000000000000 DRTVWR-102_3.2.2-beta1
+0000000000000000000000000000000000000000 3.2.1-release
+0000000000000000000000000000000000000000 DRTVWR-99_3.2.1-release
+0000000000000000000000000000000000000000 3.2.3-start
+0000000000000000000000000000000000000000 3.2.4-beta1
+0000000000000000000000000000000000000000 3.2.4-start
+0000000000000000000000000000000000000000 DRTVWR-104_3.2.4-beta1
+0000000000000000000000000000000000000000 3.2.4-release
+0000000000000000000000000000000000000000 DRTVWR-103_3.2.4-release
+0000000000000000000000000000000000000000 3.2.5-start
+0000000000000000000000000000000000000000 3.2.5-beta1
+0000000000000000000000000000000000000000 DRTVWR-106_3.2.5-beta1
+0000000000000000000000000000000000000000 3.2.5-beta2
+0000000000000000000000000000000000000000 DRTVWR-107_3.2.5-beta2
+0000000000000000000000000000000000000000 3.2.5-release
+0000000000000000000000000000000000000000 DRTVWR-105_3.2.5-release
+0000000000000000000000000000000000000000 3.2.6-start
+0000000000000000000000000000000000000000 3.2.6-beta1
+0000000000000000000000000000000000000000 DRTVWR-109_3.2.6-beta1
+0000000000000000000000000000000000000000 3.2.7-start
+0000000000000000000000000000000000000000 3.2.7-beta1
+0000000000000000000000000000000000000000 DRTVWR-111_3.2.7-beta1
+0000000000000000000000000000000000000000 3.2.8-start
+0000000000000000000000000000000000000000 3.2.8-beta1
+0000000000000000000000000000000000000000 DRTVWR-114_3.2.8-beta1
+0000000000000000000000000000000000000000 3.2.8-beta2
+0000000000000000000000000000000000000000 DRTVWR-115_3.2.8-beta2
+0000000000000000000000000000000000000000 3.2.8-release
+0000000000000000000000000000000000000000 DRTVWR-113_3.2.8-release
+0000000000000000000000000000000000000000 3.2.9-start
+0000000000000000000000000000000000000000 3.2.9-beta1
+0000000000000000000000000000000000000000 DRTVWR-117_3.2.9-beta1
+0000000000000000000000000000000000000000 3.2.9-beta2
+0000000000000000000000000000000000000000 DRTVWR-118_3.2.9-beta2
+0000000000000000000000000000000000000000 3.3.0-beta1
+0000000000000000000000000000000000000000 3.3.0-start
+0000000000000000000000000000000000000000 DRTVWR-119
+0000000000000000000000000000000000000000 3.3.0-release
+0000000000000000000000000000000000000000 3.3.1-start
+0000000000000000000000000000000000000000 DRTVWR-125
+0000000000000000000000000000000000000000 3.3.1-beta1
+0000000000000000000000000000000000000000 3.3.1-beta2
+0000000000000000000000000000000000000000 DRTVWR-139
+0000000000000000000000000000000000000000 viewer-beta-candidate
+0000000000000000000000000000000000000000 3.3.1-release
+0000000000000000000000000000000000000000 3.3.2-beta1
+0000000000000000000000000000000000000000 3.3.2-beta2
+0000000000000000000000000000000000000000 3.3.2-release
+0000000000000000000000000000000000000000 viewer-release-candidate
+0000000000000000000000000000000000000000 DRTVWR-156
+0000000000000000000000000000000000000000 DRTVWR-148
+0000000000000000000000000000000000000000 DRTVWR-155
+0000000000000000000000000000000000000000 DRTVWR-153
+0000000000000000000000000000000000000000 DRTVWR-160
+0000000000000000000000000000000000000000 3.3.3-beta1
+0000000000000000000000000000000000000000 DRTVWR-144
+0000000000000000000000000000000000000000 DRTVWR-164
+0000000000000000000000000000000000000000 DRTVWR-162
+0000000000000000000000000000000000000000 DRTVWR-165
+0000000000000000000000000000000000000000 3.3.3-beta2
+0000000000000000000000000000000000000000 DRTVWR-169
+0000000000000000000000000000000000000000 3.3.3-beta3
+0000000000000000000000000000000000000000 3.3.3-release
+0000000000000000000000000000000000000000 DRTVWR-159
+0000000000000000000000000000000000000000 DRTVWR-157
+0000000000000000000000000000000000000000 DRTVWR-161
+0000000000000000000000000000000000000000 DRTVWR-163
+0000000000000000000000000000000000000000 DRTVWR-171
+0000000000000000000000000000000000000000 DRTVWR-168
+0000000000000000000000000000000000000000 DRTVWR-170
+0000000000000000000000000000000000000000 DRTVWR-158
+0000000000000000000000000000000000000000 3.3.4-beta1
+0000000000000000000000000000000000000000 DRTVWR-173
+0000000000000000000000000000000000000000 DRTVWR-174
+0000000000000000000000000000000000000000 3.3.4-beta2
+0000000000000000000000000000000000000000 DRTVWR-176
+0000000000000000000000000000000000000000 DRTVWR-177
+0000000000000000000000000000000000000000 3.3.4-beta3
+0000000000000000000000000000000000000000 DRTVWR-180
+0000000000000000000000000000000000000000 DRTVWR-183
+0000000000000000000000000000000000000000 3.3.4-beta4
+0000000000000000000000000000000000000000 DRTVWR-184
+0000000000000000000000000000000000000000 3.3.4-beta5
+0000000000000000000000000000000000000000 3.3.4-release
+0000000000000000000000000000000000000000 DRTVWR-167
+0000000000000000000000000000000000000000 DRTVWR-175
+0000000000000000000000000000000000000000 DRTVWR-182
+0000000000000000000000000000000000000000 3.4.0-beta1
+0000000000000000000000000000000000000000 DRTVWR-189
+0000000000000000000000000000000000000000 DRTVWR-190
+0000000000000000000000000000000000000000 DRTVWR-192
+0000000000000000000000000000000000000000 DRTVWR-195
+0000000000000000000000000000000000000000 DRTVWR-193
+0000000000000000000000000000000000000000 DRTVWR-196
+0000000000000000000000000000000000000000 DRTVWR-198
+0000000000000000000000000000000000000000 DRTVWR-197
+0000000000000000000000000000000000000000 3.4.0-beta2
+0000000000000000000000000000000000000000 DRTVWR-200
+0000000000000000000000000000000000000000 3.4.0-beta3
+0000000000000000000000000000000000000000 DRTVWR-199
+0000000000000000000000000000000000000000 3.3.4-release2
+0000000000000000000000000000000000000000 DRTVWR-201
+0000000000000000000000000000000000000000 3.4.0-beta4
+0000000000000000000000000000000000000000 3.4.0-beta5
+0000000000000000000000000000000000000000 DRTVWR-207
+0000000000000000000000000000000000000000 3.3.4-release3
+0000000000000000000000000000000000000000 DRTVWR-212
+0000000000000000000000000000000000000000 DRTVWR-213
+0000000000000000000000000000000000000000 3.3.4-beta6
+0000000000000000000000000000000000000000 DRTVWR-215
+0000000000000000000000000000000000000000 3.4.0-beta7
+0000000000000000000000000000000000000000 3.4.0-release
+0000000000000000000000000000000000000000 3.4.1-beta1
+0000000000000000000000000000000000000000 3.4.1-beta1a
+0000000000000000000000000000000000000000 DRTVWR-220
+0000000000000000000000000000000000000000 DRTVWR-221
+0000000000000000000000000000000000000000 3.4.1-beta3
+0000000000000000000000000000000000000000 DRTVWR-222
+0000000000000000000000000000000000000000 3.4.1-beta4
+0000000000000000000000000000000000000000 DRTVWR-224
+0000000000000000000000000000000000000000 3.4.1-beta5
+0000000000000000000000000000000000000000 DRTVWR-226
+0000000000000000000000000000000000000000 DRTVWR-179
+0000000000000000000000000000000000000000 3.4.1-beta6
+0000000000000000000000000000000000000000 DRTVWR-227
+0000000000000000000000000000000000000000 3.4.1-beta7
+0000000000000000000000000000000000000000 DRTVWR-228
+0000000000000000000000000000000000000000 3.4.1-beta8
+0000000000000000000000000000000000000000 DRTVWR-231
+0000000000000000000000000000000000000000 DRTVWR-233
+0000000000000000000000000000000000000000 3.4.1-beta9
+0000000000000000000000000000000000000000 3.4.1-beta10
+0000000000000000000000000000000000000000 DRTVWR-235
+0000000000000000000000000000000000000000 DRTVWR-236
+0000000000000000000000000000000000000000 3.4.1-beta11
+0000000000000000000000000000000000000000 DRTVWR-237
+0000000000000000000000000000000000000000 3.4.1-beta12
+0000000000000000000000000000000000000000 3.4.1-release
+0000000000000000000000000000000000000000 DRTVWR-186
+0000000000000000000000000000000000000000 DRTVWR-181
+0000000000000000000000000000000000000000 DRTVWR-188
+0000000000000000000000000000000000000000 DRTVWR-191
+0000000000000000000000000000000000000000 DRTVWR-194
+0000000000000000000000000000000000000000 DRTVWR-203
+0000000000000000000000000000000000000000 DRTVWR-202
+0000000000000000000000000000000000000000 oz-build-test-tag
+0000000000000000000000000000000000000000 DRTVWR-205
+0000000000000000000000000000000000000000 DRTVWR-206
+0000000000000000000000000000000000000000 DRTVWR-219
+0000000000000000000000000000000000000000 DRTVWR-217
+0000000000000000000000000000000000000000 3.4.2-beta1
+0000000000000000000000000000000000000000 DRTVWR-216
+0000000000000000000000000000000000000000 3.4.2-beta2
+0000000000000000000000000000000000000000 DRTVWR-242
+0000000000000000000000000000000000000000 3.4.2-beta3
+0000000000000000000000000000000000000000 DRTVWR-243
+0000000000000000000000000000000000000000 3.4.2-beta4
+0000000000000000000000000000000000000000 3.4.2-release
+0000000000000000000000000000000000000000 DRTVWR-208
+0000000000000000000000000000000000000000 DRTVWR-223
+0000000000000000000000000000000000000000 DRTVWR-240
+0000000000000000000000000000000000000000 DRTVWR-209
+0000000000000000000000000000000000000000 DRTVWR-238
+0000000000000000000000000000000000000000 DRTVWR-210
+0000000000000000000000000000000000000000 DRTVWR-241
+0000000000000000000000000000000000000000 DRTVWR-232
+0000000000000000000000000000000000000000 DRTVWR-245
+0000000000000000000000000000000000000000 3.4.3-beta1
+0000000000000000000000000000000000000000 DRTVWR-252
+0000000000000000000000000000000000000000 DRTVWR-251
+0000000000000000000000000000000000000000 DRTVWR-253
+0000000000000000000000000000000000000000 DRTVWR-254
+0000000000000000000000000000000000000000 DRTVWR-256
+0000000000000000000000000000000000000000 DRTVWR-258
+0000000000000000000000000000000000000000 DRTVWR-257
+0000000000000000000000000000000000000000 DRTVWR-259
+0000000000000000000000000000000000000000 DRTVWR-265
+0000000000000000000000000000000000000000 DRTVWR-266
+0000000000000000000000000000000000000000 DRTVWR-267
+0000000000000000000000000000000000000000 3.4.3-beta3
+0000000000000000000000000000000000000000 3.4.3-release
+0000000000000000000000000000000000000000 DRTVWR-229
+0000000000000000000000000000000000000000 DRTVWR-246
+0000000000000000000000000000000000000000 DRTVWR-247
+0000000000000000000000000000000000000000 DRTVWR-249
+0000000000000000000000000000000000000000 DRTVWR-230
+0000000000000000000000000000000000000000 DRTVWR-255
+0000000000000000000000000000000000000000 DRTVWR-260
+0000000000000000000000000000000000000000 DRTVWR-244
+0000000000000000000000000000000000000000 3.4.4-beta1
+0000000000000000000000000000000000000000 DRTVWR-270
+0000000000000000000000000000000000000000 3.4.4-beta2
+0000000000000000000000000000000000000000 DRTVWR-271
+0000000000000000000000000000000000000000 3.4.4-beta3
+0000000000000000000000000000000000000000 DRTVWR-273
+0000000000000000000000000000000000000000 DRTVWR-275
+0000000000000000000000000000000000000000 3.4.4-beta4
+0000000000000000000000000000000000000000 3.4.4-release
+0000000000000000000000000000000000000000 DRTVWR-268
+0000000000000000000000000000000000000000 DRTVWR-272
+0000000000000000000000000000000000000000 DRTVWR-269
+0000000000000000000000000000000000000000 DRTVWR-250
+0000000000000000000000000000000000000000 DRTVWR-277
+0000000000000000000000000000000000000000 DRTVWR-276
+0000000000000000000000000000000000000000 DRTVWR-279
+0000000000000000000000000000000000000000 DRTVWR-280
+0000000000000000000000000000000000000000 3.4.5-beta1
+0000000000000000000000000000000000000000 DRTVWR-281
+0000000000000000000000000000000000000000 DRTVWR-283
+0000000000000000000000000000000000000000 3.4.5-beta2
+0000000000000000000000000000000000000000 DRTVWR-286
+0000000000000000000000000000000000000000 DRTVWR-287
+0000000000000000000000000000000000000000 3.4.5-beta3
+0000000000000000000000000000000000000000 DRTVWR-289
+0000000000000000000000000000000000000000 DRTVWR-290
+0000000000000000000000000000000000000000 DRTVWR-291
+0000000000000000000000000000000000000000 DRTVWR-292
+0000000000000000000000000000000000000000 3.4.5-beta4
+0000000000000000000000000000000000000000 DRTVWR-296
+0000000000000000000000000000000000000000 DRTVWR-297
+0000000000000000000000000000000000000000 3.4.5-beta5
+4f777ffb99fefdc6497c61385c22688ff149c659 SL-2.0.0
+668851b2ef0f8cf8df07a0fba429e4a6c1e70abb SL-2.0.1
+b03065d018b8a2e28b7de85b293a4c992cb4c12d SL-2.1.0
+bb38ff1a763738609e1b3cada6d15fa61e5e84b9 SL-2.1.1
+1415e6538d54fd5d568ee88343424d57c6803c2c SL-2.2.0
+6ad3d6fa35a4e320e9ce442fce2bf9c7fc852556 SL-2.3.0
+1ed382c6a08ba3850b6ce9061bc551ddece0ea07 SL-2.4.0
+b723921b5c711bd24dbe77dc76ef488b544dac78 SL-2.5.0
+4dede9ae1ec74d41f6887719f6f1de7340d8578d SL-2.5.1
+b53a0576eec80614d7767ed72b40ed67aeff27c9 SL-2.5.2
+42f32494bac475d0737799346f6831558ae8bf5d SL-2.6.0
+c9182ed77d427c759cfacf49a7b71a2e20d522aa SL-2.6.1
+214180ad5714ce8392b82bbebcc92f4babd98300 SL-2.6.2
+8f2da1701c81a62352df2b8d413d27fb2cade9a6 SL-2.6.3
+dac76a711da5f1489a01c1fa62ec97d99c25736d SL-2.6.6
+be2000b946f8cb3de5f44b2d419287d4c48ec4eb SL-2.6.8
+77e5a08344c95738ab879f9671b7758cddd712a3 SL-2.6.9
+a9abb9633a266c8d2fe62411cfd1c86d32da72bf SL-2.7.1
+fe3a8e7973072ea62043c08b19b66626c1a720eb SL-2.7.2
+057f319dd8eccdf63a54d99686c68cdcb31b6abc SL-2.7.4
+6866d9df6efbd441c66451debd376d21211de39c SL-2.7.5
+493d9127ee50e84ba08a736a65a23ca86f7a5b01 SL-2.8.0
+29e93d7e19991011bd12b5748142b11a5dcb4370 SL-2.8.1
+fb85792b84bf28428889c4cc966469d92e5dac4c SL-2.8.3
+1778f26b6d0ae762dec3ca37140f66620f2485d9 SL-3.0.0
+0496d2f74043cf4e6058e76ac3db03d44cff42ce SL-3.0.3
+ae2de7b0b33c03dc5bdf3a7bfa54463b512221b2 SL-3.1.0
+3150219d229d628f0c15e58e8a51511cbd97e58d SL-3.2.0
+a8c7030d6845186fac7c188be4323a0e887b4184 SL-3.2.1
+bd6bcde2584491fd9228f1fa51c4575f4e764e19 SL-3.2.4
+c6175c955a19e9b9353d242889ec1779b5762522 SL-3.2.5
+51b2fd52e36aab8f670e0874e7e1472434ec4b4a SL-3.2.8
+5e8d2662f38a66eca6c591295f5880d47afc73f7 SL-3.3.0
+c623bbc854b6f7ee1b33a3718f76715046aa2937 SL-3.3.1
+675668bd24d3bea570814f71762a2a806f7e1b8d SL-3.3.2
+6428242e124b523813bfaf4c45b3d422f0298c81 SL-3.3.3
+28e100d0379a2b0710c57647a28fc5239d3d7b99 SL-3.3.4
+97977c67245f52db20eb15f1918cc0f24778cabc SL-3.4.0
+e59ffd3fe0838ae6b09b242a6e9df71761b88f41 SL-3.4.1
+16310aabccf315870f7cc9bf966926c0ad6954fa SL-3.4.2
+0a2ca6546b499239afeb66d17b2fadbcdbe36ab1 SL-3.4.3
+e1bb1ae7d8b12faeb37933a737c199cc9b9f89cc SL-3.4.4
+425f96b1e81e01644bf5e951961e7d1023bffb89 RLVa-1.2.0
+fc0cbb86f5bd6e7737159e35aea2c4cf9f619b62 RLVa-1.2.1
+43cb7dc1804de1a25c0b2b3f0715584af1f8b470 RLVa-1.2.2
+89532c8dfd5b6c29f1cb032665b44a74a52452e1 RLVa-1.3.0
+7bc5039ccf0b36eafbf6ce33a52b5e26332aa04c RLVa-1.3.1
+a563f7e215c7883c1cfd20908085687a0ed96284 RLVa-1.4.0
+40644beae9c4a617504163d5c9f195dc7bfff1b4 RLVa-1.4.1
+8787094c309a44ca32b7472acc9217a3c37f00c3 RLVa-1.4.2
+11c6c85ddd223bcbd6b3afc53f9a0f5fd349ba65 RLVa-1.4.3
+53b44208d44a601fe24e78c1a1909dc82356cded RLVa-1.4.4
+6522747820037cc11e5b7d0491a0a9808a958709 RLVa-1.4.5
+0c8f23b2c4cf96d1a08bd527b3ccb6339a9fdb60 RLVa-1.4.6
+674db463770b78f836fc9c87a1b2235e212a576c RLVa-1.4.7
--- a/autobuild.xml
+++ b/autobuild.xml
@ -1334,9 +1334,9 @@
            <key>archive</key>
            <map>
              <key>hash</key>
-              <string>8180c6f8d96a76c0c4b7746eb9e98964</string>
+              <string>e0dbab27a77d6a864658da4526d7a9c8</string>
              <key>url</key>
-              <string>http://s3-proxy.lindenlab.com/private-builds-secondlife-com/hg/repo/llappearanceutility-source/rev/268052/arch/Linux/installer/llappearanceutility_source-0.1-linux-20121212.tar.bz2</string>
+              <string>http://s3-proxy.lindenlab.com/private-builds-secondlife-com/hg/repo/llappearanceutility-source/rev/270227/arch/Linux/installer/llappearanceutility_source-0.1-linux-20130211.tar.bz2</string>
            </map>
            <key>name</key>
            <string>linux</string>
@ -1812,9 +1812,9 @@
            <key>archive</key>
            <map>
              <key>hash</key>
-              <string>ca5765af55f798724d601720afdf6953</string>
+              <string>2fbd3c2523c45923245b55551fae5e53</string>
              <key>url</key>
-              <string>http://s3.amazonaws.com/viewer-source-downloads/install_pkgs/openjpeg-1.4-windows-20110302.tar.bz2</string>
+              <string>http://viewer.catznip.com/downloads/openjpeg-1.4-windows-20110622.tar.bz2</string>
            </map>
            <key>name</key>
            <string>windows</string>
--- a/indra/CMakeLists.txt
+++ b/indra/CMakeLists.txt
@ -90,8 +90,8 @@ add_subdirectory(${LIBS_OPEN_PREFIX}llui)
 add_subdirectory(${LIBS_OPEN_PREFIX}viewer_components)

 if (LL_TESTS OR NOT STANDALONE)
-  # Legacy C++ tests. Build always, run if LL_TESTS is true.
-  add_subdirectory(${VIEWER_PREFIX}test)
+# Legacy C++ tests. Build always, run if LL_TESTS is true.
+add_subdirectory(${VIEWER_PREFIX}test)
 endif (LL_TESTS OR NOT STANDALONE)

 # viewer media plugins
--- a/indra/cmake/LLAddBuildTest.cmake
+++ b/indra/cmake/LLAddBuildTest.cmake
--- a/indra/cmake/Variables.cmake
+++ b/indra/cmake/Variables.cmake
@ -187,7 +187,6 @@ set(STANDALONE OFF CACHE BOOL "Do not use Linden-supplied prebuilt libraries.")
 set(UNATTENDED OFF CACHE BOOL "Should be set to ON for building with VC Express editions.")

 set(USE_PRECOMPILED_HEADERS ON CACHE BOOL "Enable use of precompiled header directives where supported.")
-
 # <FS:ND> When using Havok, we have to turn OpenSim support off
 if( HAVOK_TPV )
 if( OPENSIM )
--- a/indra/linux_updater/CMakeLists.txt
+++ b/indra/linux_updater/CMakeLists.txt
@ -0,0 +1,57 @@
+# -*- cmake -*-
+
+project(linux_updater)
+
+include(00-Common)
+include(CURL)
+include(CARes)
+include(OpenSSL)
+include(UI)
+include(LLCommon)
+include(LLMessage)
+include(LLVFS)
+include(LLXML)
+include(LLUI)
+include(Linking)
+
+include_directories(
+    ${LLCOMMON_INCLUDE_DIRS}
+    ${LLVFS_INCLUDE_DIRS}
+    ${LLXML_INCLUDE_DIRS}
+    ${LLUI_INCLUDE_DIRS}
+    ${CURL_INCLUDE_DIRS}
+    ${CARES_INCLUDE_DIRS}
+    ${OPENSSL_INCLUDE_DIRS}
+    ${UI_INCLUDE_DIRS}
+    )
+include_directories(SYSTEM
+    ${LLCOMMON_SYSTEM_INCLUDE_DIRS}
+    ${LLXML_SYSTEM_INCLUDE_DIRS}
+    )
+
+set(linux_updater_SOURCE_FILES linux_updater.cpp)
+
+set(linux_updater_HEADER_FILES CMakeLists.txt)
+
+set_source_files_properties(${linux_updater_HEADER_FILES}
+                            PROPERTIES HEADER_FILES_ONLY TRUE)
+
+list(APPEND linux_updater_SOURCE_FILES ${linux_updater_HEADER_FILES})
+
+add_executable(linux-updater ${linux_updater_SOURCE_FILES})
+
+target_link_libraries(linux-updater
+    ${CURL_LIBRARIES}
+    ${CARES_LIBRARIES}
+    ${OPENSSL_LIBRARIES}
+    ${CRYPTO_LIBRARIES}
+    ${LLMESSAGE_LIBRARIES}
+    ${UI_LIBRARIES}
+    ${LLXML_LIBRARIES}
+    ${LLUI_LIBRARIES}
+    ${LLVFS_LIBRARIES}
+    ${LLCOMMON_LIBRARIES}
+    )
+
+add_custom_target(linux-updater-target ALL
+                  DEPENDS linux-updater)
--- a/indra/linux_updater/linux_updater.cpp
+++ b/indra/linux_updater/linux_updater.cpp
@ -0,0 +1,924 @@
+/**
+ * @file linux_updater.cpp
+ * @author Kyle Ambroff <ambroff@lindenlab.com>, Tofu Linden
+ * @brief Viewer update program for unix platforms that support GTK+
+ *
+ * $LicenseInfo:firstyear=2008&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 <unistd.h>
+#include <signal.h>
+#include <errno.h>
+
+#include "linden_common.h"
+#include "llerrorcontrol.h"
+#include "llfile.h"
+#include "lldir.h"
+#include "lldiriterator.h"
+
+/*==========================================================================*|
+// IQA-490: Use of LLTrans -- by this program at least -- appears to be buggy.
+// With it, the 3.3.2 beta 1 linux-updater.bin crashes; without it seems stable.
+#include "llxmlnode.h"
+#include "lltrans.h"
+|*==========================================================================*/
+
+static class LLTrans
+{
+public:
+	LLTrans();
+	static std::string getString(const std::string& key);
+
+private:
+	std::string _getString(const std::string& key) const;
+
+	typedef std::map<std::string, std::string> MessageMap;
+	MessageMap mMessages;
+} sLLTransInstance;
+
+#include <curl/curl.h>
+#include <map>
+#include <boost/foreach.hpp>
+
+extern "C" {
+#include <gtk/gtk.h>
+}
+
+const guint UPDATE_PROGRESS_TIMEOUT = 100;
+const guint UPDATE_PROGRESS_TEXT_TIMEOUT = 1000;
+const guint ROTATE_IMAGE_TIMEOUT = 8000;
+
+typedef struct _updater_app_state {
+	std::string app_name;
+	std::string url;
+	std::string file;
+	std::string image_dir;
+	std::string dest_dir;
+	std::string strings_dirs;
+	std::string strings_file;
+
+	LLDirIterator *image_dir_iter;
+
+	GtkWidget *window;
+	GtkWidget *progress_bar;
+	GtkWidget *image;
+
+	double progress_value;
+	bool activity_mode;
+
+	guint image_rotation_timeout_id;
+	guint progress_update_timeout_id;
+	guint update_progress_text_timeout_id;
+
+	bool failure;
+} UpdaterAppState;
+
+// List of entries from strings.xml to always replace
+static std::set<std::string> default_trans_args;
+void init_default_trans_args()
+{
+        default_trans_args.insert("SECOND_LIFE"); // World
+        default_trans_args.insert("APP_NAME");
+        default_trans_args.insert("SECOND_LIFE_GRID");
+        default_trans_args.insert("SUPPORT_SITE");
+}
+
+bool translate_init(std::string comma_delim_path_list,
+		    std::string base_xml_name)
+{
+	return true;
+/*==========================================================================*|
+	init_default_trans_args();
+
+	// extract paths string vector from comma-delimited flat string
+	std::vector<std::string> paths;
+	LLStringUtil::getTokens(comma_delim_path_list, paths, ","); // split over ','
+
+	for(std::vector<std::string>::iterator it = paths.begin(), end_it = paths.end();
+		it != end_it;
+		++it)
+	{
+		(*it) = gDirUtilp->findSkinnedFilename(*it, base_xml_name);
+	}
+
+	// suck the translation xml files into memory
+	LLXMLNodePtr root;
+	bool success = LLXMLNode::getLayeredXMLNode(root, paths);
+	if (!success)
+	{
+		// couldn't load string table XML
+		return false;
+	}
+	else
+	{
+		// get those strings out of the XML
+		LLTrans::parseStrings(root, default_trans_args);
+		return true;
+	}
+|*==========================================================================*/
+}
+
+
+void updater_app_ui_init(void);
+void updater_app_quit(UpdaterAppState *app_state);
+void parse_args_and_init(int argc, char **argv, UpdaterAppState *app_state);
+std::string next_image_filename(std::string& image_path, LLDirIterator& iter);
+void display_error(GtkWidget *parent, std::string title, std::string message);
+BOOL install_package(std::string package_file, std::string destination);
+BOOL spawn_viewer(UpdaterAppState *app_state);
+
+extern "C" {
+	void on_window_closed(GtkWidget *sender, GdkEvent *event, gpointer state);
+	gpointer worker_thread_cb(gpointer *data);
+	int download_progress_cb(gpointer data, double t, double d, double utotal, double ulnow);
+	gboolean rotate_image_cb(gpointer data);
+	gboolean progress_update_timeout(gpointer data);
+	gboolean update_progress_text_timeout(gpointer data);
+}
+
+void updater_app_ui_init(UpdaterAppState *app_state)
+{
+	GtkWidget *vbox;
+	GtkWidget *summary_label;
+	GtkWidget *description_label;
+	GtkWidget *frame;
+
+	llassert(app_state != NULL);
+
+	// set up window and main container
+	std::string window_title = LLTrans::getString("UpdaterWindowTitle");
+	app_state->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+	gtk_window_set_title(GTK_WINDOW(app_state->window),
+			     window_title.c_str());
+	gtk_window_set_resizable(GTK_WINDOW(app_state->window), FALSE);
+	gtk_window_set_position(GTK_WINDOW(app_state->window),
+				GTK_WIN_POS_CENTER_ALWAYS);
+
+	gtk_container_set_border_width(GTK_CONTAINER(app_state->window), 12);
+	g_signal_connect(G_OBJECT(app_state->window), "delete-event",
+			 G_CALLBACK(on_window_closed), app_state);
+
+	vbox = gtk_vbox_new(FALSE, 6);
+	gtk_container_add(GTK_CONTAINER(app_state->window), vbox);
+
+	// set top label
+	std::ostringstream label_ostr;
+	label_ostr << "<big><b>"
+		   << LLTrans::getString("UpdaterNowUpdating")
+		   << "</b></big>";
+
+	summary_label = gtk_label_new(NULL);
+	gtk_label_set_use_markup(GTK_LABEL(summary_label), TRUE);
+	gtk_label_set_markup(GTK_LABEL(summary_label),
+			     label_ostr.str().c_str());
+	gtk_misc_set_alignment(GTK_MISC(summary_label), 0, 0.5);
+	gtk_box_pack_start(GTK_BOX(vbox), summary_label, FALSE, FALSE, 0);
+
+	// create the description label
+	description_label = gtk_label_new(LLTrans::getString("UpdaterUpdatingDescriptive").c_str());
+	gtk_label_set_line_wrap(GTK_LABEL(description_label), TRUE);
+	gtk_misc_set_alignment(GTK_MISC(description_label), 0, 0.5);
+	gtk_box_pack_start(GTK_BOX(vbox), description_label, FALSE, FALSE, 0);
+
+	// If an image path has been set, load the background images
+	if (!app_state->image_dir.empty()) {
+		frame = gtk_frame_new(NULL);
+		gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
+		gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0);
+
+		// load the first image
+		app_state->image = gtk_image_new_from_file
+			(next_image_filename(app_state->image_dir, *app_state->image_dir_iter).c_str());
+		gtk_widget_set_size_request(app_state->image, 340, 310);
+		gtk_container_add(GTK_CONTAINER(frame), app_state->image);
+
+		// rotate the images every 5 seconds
+		app_state->image_rotation_timeout_id = g_timeout_add
+			(ROTATE_IMAGE_TIMEOUT, rotate_image_cb, app_state);
+	}
+
+	// set up progress bar, and update it roughly every 1/10 of a second
+	app_state->progress_bar = gtk_progress_bar_new();
+	gtk_progress_bar_set_text(GTK_PROGRESS_BAR(app_state->progress_bar),
+				  LLTrans::getString("UpdaterProgressBarTextWithEllipses").c_str());
+	gtk_box_pack_start(GTK_BOX(vbox),
+			   app_state->progress_bar, FALSE, TRUE, 0);
+	app_state->progress_update_timeout_id = g_timeout_add
+		(UPDATE_PROGRESS_TIMEOUT, progress_update_timeout, app_state);
+	app_state->update_progress_text_timeout_id = g_timeout_add
+		(UPDATE_PROGRESS_TEXT_TIMEOUT, update_progress_text_timeout, app_state);
+
+	gtk_widget_show_all(app_state->window);
+}
+
+gboolean rotate_image_cb(gpointer data)
+{
+	UpdaterAppState *app_state;
+	std::string filename;
+
+	llassert(data != NULL);
+	app_state = (UpdaterAppState *) data;
+
+	filename = next_image_filename(app_state->image_dir, *app_state->image_dir_iter);
+
+	gdk_threads_enter();
+	gtk_image_set_from_file(GTK_IMAGE(app_state->image), filename.c_str());
+	gdk_threads_leave();
+
+	return TRUE;
+}
+
+std::string next_image_filename(std::string& image_path, LLDirIterator& iter)
+{
+	std::string image_filename;
+	iter.next(image_filename);
+	return gDirUtilp->add(image_path, image_filename);
+}
+
+void on_window_closed(GtkWidget *sender, GdkEvent* event, gpointer data)
+{
+	UpdaterAppState *app_state;
+
+	llassert(data != NULL);
+	app_state = (UpdaterAppState *) data;
+
+	updater_app_quit(app_state);
+}
+
+void updater_app_quit(UpdaterAppState *app_state)
+{
+	if (app_state != NULL)
+	{
+		g_source_remove(app_state->progress_update_timeout_id);
+
+		if (!app_state->image_dir.empty())
+		{
+			g_source_remove(app_state->image_rotation_timeout_id);
+		}
+	}
+
+	gtk_main_quit();
+}
+
+void display_error(GtkWidget *parent, std::string title, std::string message)
+{
+	GtkWidget *dialog;
+
+	dialog = gtk_message_dialog_new(GTK_WINDOW(parent),
+					GTK_DIALOG_DESTROY_WITH_PARENT,
+					GTK_MESSAGE_ERROR,
+					GTK_BUTTONS_OK,
+					"%s", message.c_str());
+	gtk_window_set_title(GTK_WINDOW(dialog), title.c_str());
+	gtk_dialog_run(GTK_DIALOG(dialog));
+	gtk_widget_destroy(dialog);
+}
+
+gpointer worker_thread_cb(gpointer data)
+{
+	UpdaterAppState *app_state;
+	CURL *curl;
+	CURLcode result;
+	FILE *package_file;
+	GError *error = NULL;
+	int fd;
+
+	//g_return_val_if_fail (data != NULL, NULL);
+	app_state = (UpdaterAppState *) data;
+
+	try {
+
+		if(!app_state->url.empty())
+		{
+			char* tmp_local_filename = NULL;
+			// create temporary file to store the package.
+			fd = g_file_open_tmp
+				("secondlife-update-XXXXXX", &tmp_local_filename, &error);
+			if (error != NULL)
+			{
+				llerrs << "Unable to create temporary file: "
+					   << error->message
+					   << llendl;
+
+				g_error_free(error);
+				throw 0;
+			}
+
+			if(tmp_local_filename != NULL)
+			{
+				app_state->file = tmp_local_filename;
+				g_free(tmp_local_filename);
+			}
+
+			package_file = fdopen(fd, "wb");
+			if (package_file == NULL)
+			{
+				llerrs << "Failed to create temporary file: "
+					   << app_state->file.c_str()
+					   << llendl;
+
+				gdk_threads_enter();
+				display_error(app_state->window,
+							  LLTrans::getString("UpdaterFailDownloadTitle"),
+							  LLTrans::getString("UpdaterFailUpdateDescriptive"));
+				gdk_threads_leave();
+				throw 0;
+			}
+
+			// initialize curl and start downloading the package
+			llinfos << "Downloading package: " << app_state->url << llendl;
+
+			curl = curl_easy_init();
+			if (curl == NULL)
+			{
+				llerrs << "Failed to initialize libcurl" << llendl;
+
+				gdk_threads_enter();
+				display_error(app_state->window,
+							  LLTrans::getString("UpdaterFailDownloadTitle"),
+							  LLTrans::getString("UpdaterFailUpdateDescriptive"));
+				gdk_threads_leave();
+				throw 0;
+			}
+
+			curl_easy_setopt(curl, CURLOPT_URL, app_state->url.c_str());
+			curl_easy_setopt(curl, CURLOPT_NOSIGNAL, TRUE);
+			curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, TRUE);
+			curl_easy_setopt(curl, CURLOPT_WRITEDATA, package_file);
+			curl_easy_setopt(curl, CURLOPT_NOPROGRESS, FALSE);
+			curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION,
+							 &download_progress_cb);
+			curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, app_state);
+
+			result = curl_easy_perform(curl);
+			fclose(package_file);
+			curl_easy_cleanup(curl);
+
+			if (result)
+			{
+				llerrs << "Failed to download update: "
+					   << app_state->url
+					   << llendl;
+
+				gdk_threads_enter();
+				display_error(app_state->window,
+							  LLTrans::getString("UpdaterFailDownloadTitle"),
+							  LLTrans::getString("UpdaterFailUpdateDescriptive"));
+				gdk_threads_leave();
+
+				throw 0;
+			}
+		}
+
+		// now pulse the progres bar back and forth while the package is
+		// being unpacked
+		gdk_threads_enter();
+		std::string installing_msg = LLTrans::getString("UpdaterNowInstalling");
+		gtk_progress_bar_set_text(
+			GTK_PROGRESS_BAR(app_state->progress_bar),
+			installing_msg.c_str());
+		app_state->activity_mode = TRUE;
+		gdk_threads_leave();
+
+		// *TODO: if the destination is not writable, terminate this
+		// thread and show file chooser?
+		if (!install_package(app_state->file.c_str(), app_state->dest_dir))
+		{
+			llwarns << "Failed to install package to destination: "
+				<< app_state->dest_dir
+				<< llendl;
+
+			gdk_threads_enter();
+			display_error(app_state->window,
+						  LLTrans::getString("UpdaterFailInstallTitle"),
+						  LLTrans::getString("UpdaterFailUpdateDescriptive"));
+			//"Failed to update " + app_state->app_name,
+			gdk_threads_leave();
+			throw 0;
+		}
+
+		// try to spawn the new viewer
+		if (!spawn_viewer(app_state))
+		{
+			llwarns << "Viewer was not installed properly in : "
+				<< app_state->dest_dir
+				<< llendl;
+
+			gdk_threads_enter();
+			display_error(app_state->window,
+						  LLTrans::getString("UpdaterFailStartTitle"),
+						  LLTrans::getString("UpdaterFailUpdateDescriptive"));
+			gdk_threads_leave();
+			throw 0;
+		}
+	}
+	catch (...)
+	{
+		app_state->failure = TRUE;
+	}
+
+	gdk_threads_enter();
+	updater_app_quit(app_state);
+	gdk_threads_leave();
+
+	return NULL;
+}
+
+
+gboolean less_anal_gspawnsync(gchar **argv,
+			      gchar **stderr_output,
+			      gint *child_exit_status,
+			      GError **spawn_error)
+{
+	// store current SIGCHLD handler if there is one, replace with default
+	// handler to make glib happy
+	struct sigaction sigchld_backup;
+	struct sigaction sigchld_appease_glib;
+	sigchld_appease_glib.sa_handler = SIG_DFL;
+	sigemptyset(&sigchld_appease_glib.sa_mask);
+	sigchld_appease_glib.sa_flags = 0;
+	sigaction(SIGCHLD, &sigchld_appease_glib, &sigchld_backup);
+
+	gboolean rtn = g_spawn_sync(NULL,
+				    argv,
+				    NULL,
+				    (GSpawnFlags) (G_SPAWN_STDOUT_TO_DEV_NULL),
+				    NULL,
+				    NULL,
+				    NULL,
+				    stderr_output,
+				    child_exit_status,
+				    spawn_error);
+
+	// restore SIGCHLD handler
+	sigaction(SIGCHLD, &sigchld_backup, NULL);
+
+	return rtn;
+}
+
+
+// perform a rename, or perform a (prompted) root rename if that fails
+int
+rename_with_sudo_fallback(const std::string& filename, const std::string& newname)
+{
+	int rtncode = ::rename(filename.c_str(), newname.c_str());
+	lldebugs << "rename result is: " << rtncode << " / " << errno << llendl;
+	if (rtncode && (EACCES == errno || EPERM == errno || EXDEV == errno))
+	{
+		llinfos << "Permission problem in rename, or moving between different mount points.  Retrying as a mv under a sudo." << llendl;
+		// failed due to permissions, try again as a gksudo or kdesu mv wrapper hack
+		char *sudo_cmd = NULL;
+		sudo_cmd = g_find_program_in_path("gksudo");
+		if (!sudo_cmd)
+		{
+			sudo_cmd = g_find_program_in_path("kdesu");
+		}
+		if (sudo_cmd)
+		{
+			char *mv_cmd = NULL;
+			mv_cmd = g_find_program_in_path("mv");
+			if (mv_cmd)
+			{
+				char *src_string_copy = g_strdup(filename.c_str());
+				char *dst_string_copy = g_strdup(newname.c_str());
+				char* argv[] =
+					{
+						sudo_cmd,
+						mv_cmd,
+						src_string_copy,
+						dst_string_copy,
+						NULL
+					};
+
+				gchar *stderr_output = NULL;
+				gint child_exit_status = 0;
+				GError *spawn_error = NULL;
+				if (!less_anal_gspawnsync(argv, &stderr_output,
+							  &child_exit_status, &spawn_error))
+				{
+					llwarns << "Failed to spawn child process: "
+						<< spawn_error->message
+						<< llendl;
+				}
+				else if (child_exit_status)
+				{
+					llwarns << "mv command failed: "
+						<< (stderr_output ? stderr_output : "(no reason given)")
+						<< llendl;
+				}
+				else
+				{
+					// everything looks good, clear the error code
+					rtncode = 0;
+				}
+
+				g_free(src_string_copy);
+				g_free(dst_string_copy);
+				if (spawn_error) g_error_free(spawn_error);
+			}
+		}
+	}
+	return rtncode;
+}
+
+gboolean install_package(std::string package_file, std::string destination)
+{
+	char *tar_cmd = NULL;
+	std::ostringstream command;
+
+	// Find the absolute path to the 'tar' command.
+	tar_cmd = g_find_program_in_path("tar");
+	if (!tar_cmd)
+	{
+		llerrs << "`tar' was not found in $PATH" << llendl;
+		return FALSE;
+	}
+	llinfos << "Found tar command: " << tar_cmd << llendl;
+
+	// Unpack the tarball in a temporary place first, then move it to
+	// its final destination
+	std::string tmp_dest_dir = gDirUtilp->getTempFilename();
+	if (LLFile::mkdir(tmp_dest_dir, 0744))
+	{
+		llerrs << "Failed to create directory: "
+		       << destination
+		       << llendl;
+
+		return FALSE;
+	}
+
+	char *package_file_string_copy = g_strdup(package_file.c_str());
+	char *tmp_dest_dir_string_copy = g_strdup(tmp_dest_dir.c_str());
+	gchar *argv[8] = {
+		tar_cmd,
+		const_cast<gchar*>("--strip"), const_cast<gchar*>("1"),
+		const_cast<gchar*>("-xjf"),
+		package_file_string_copy,
+		const_cast<gchar*>("-C"), tmp_dest_dir_string_copy,
+		NULL,
+	};
+
+	llinfos << "Untarring package: " << package_file << llendl;
+
+	// store current SIGCHLD handler if there is one, replace with default
+	// handler to make glib happy
+	struct sigaction sigchld_backup;
+	struct sigaction sigchld_appease_glib;
+	sigchld_appease_glib.sa_handler = SIG_DFL;
+	sigemptyset(&sigchld_appease_glib.sa_mask);
+	sigchld_appease_glib.sa_flags = 0;
+	sigaction(SIGCHLD, &sigchld_appease_glib, &sigchld_backup);
+
+	gchar *stderr_output = NULL;
+	gint child_exit_status = 0;
+	GError *untar_error = NULL;
+	if (!less_anal_gspawnsync(argv, &stderr_output,
+				  &child_exit_status, &untar_error))
+	{
+		llwarns << "Failed to spawn child process: "
+			<< untar_error->message
+			<< llendl;
+		return FALSE;
+	}
+
+	if (child_exit_status)
+	{
+	 	llwarns << "Untar command failed: "
+			<< (stderr_output ? stderr_output : "(no reason given)")
+			<< llendl;
+		return FALSE;
+	}
+
+	g_free(tar_cmd);
+	g_free(package_file_string_copy);
+	g_free(tmp_dest_dir_string_copy);
+	g_free(stderr_output);
+	if (untar_error) g_error_free(untar_error);
+
+	// move the existing package out of the way if it exists
+	if (gDirUtilp->fileExists(destination))
+	{
+		std::string backup_dir = destination + ".backup";
+		int oldcounter = 1;
+		while (gDirUtilp->fileExists(backup_dir))
+		{
+			// find a foo.backup.N folder name that isn't taken yet
+			backup_dir = destination + ".backup." + llformat("%d", oldcounter);
+			++oldcounter;
+		}
+
+		if (rename_with_sudo_fallback(destination, backup_dir))
+		{
+			llwarns << "Failed to move directory: '"
+				<< destination << "' -> '" << backup_dir
+				<< llendl;
+			return FALSE;
+		}
+	}
+
+	// The package has been unpacked in a staging directory, now we just
+	// need to move it to its destination.
+	if (rename_with_sudo_fallback(tmp_dest_dir, destination))
+	{
+		llwarns << "Failed to move installation to the destination: "
+			<< destination
+			<< llendl;
+		return FALSE;
+	}
+
+	// \0/ Success!
+	return TRUE;
+}
+
+gboolean progress_update_timeout(gpointer data)
+{
+	UpdaterAppState *app_state;
+
+	llassert(data != NULL);
+
+	app_state = (UpdaterAppState *) data;
+
+	gdk_threads_enter();
+	if (app_state->activity_mode)
+	{
+		gtk_progress_bar_pulse
+			(GTK_PROGRESS_BAR(app_state->progress_bar));
+	}
+	else
+	{
+		gtk_progress_set_value(GTK_PROGRESS(app_state->progress_bar),
+				       app_state->progress_value);
+	}
+	gdk_threads_leave();
+
+	return TRUE;
+}
+
+gboolean update_progress_text_timeout(gpointer data)
+{
+	UpdaterAppState *app_state;
+
+	llassert(data != NULL);
+	app_state = (UpdaterAppState *) data;
+
+	if (app_state->activity_mode == TRUE)
+	{
+		// We no longer need this timeout, it will be removed.
+		return FALSE;
+	}
+
+	if (!app_state->progress_value)
+	{
+		return TRUE;
+	}
+
+	std::string progress_text = llformat((LLTrans::getString("UpdaterProgressBarText")+" (%.0f%%)").c_str(), app_state->progress_value);
+
+	gdk_threads_enter();
+	gtk_progress_bar_set_text(GTK_PROGRESS_BAR(app_state->progress_bar),
+				  progress_text.c_str());
+	gdk_threads_leave();
+
+	return TRUE;
+}
+
+int download_progress_cb(gpointer data,
+			 double t,
+			 double d,
+			 double utotal,
+			 double ulnow)
+{
+	UpdaterAppState *app_state;
+
+	llassert(data != NULL);
+	app_state = (UpdaterAppState *) data;
+
+	if (t <= 0.0)
+	{
+		app_state->progress_value = 0;
+	}
+	else
+	{
+		app_state->progress_value = d * 100.0 / t;
+	}
+	return 0;
+}
+
+BOOL spawn_viewer(UpdaterAppState *app_state)
+{
+	llassert(app_state != NULL);
+
+	std::string cmd = app_state->dest_dir + "/secondlife";
+	GError *error = NULL;
+
+	// We want to spawn the Viewer on the same display as the updater app
+	gboolean success = gdk_spawn_command_line_on_screen
+		(gtk_widget_get_screen(app_state->window), cmd.c_str(), &error);
+
+	if (!success)
+	{
+		llwarns << "Failed to launch viewer: " << error->message
+			<< llendl;
+	}
+
+	if (error) g_error_free(error);
+
+	return success;
+}
+
+void show_usage_and_exit()
+{
+	std::cout << "Usage: linux-updater <--url URL | --file FILE> --name NAME --dest PATH --stringsdir PATH1,PATH2 --stringsfile FILE"
+		  << "[--image-dir PATH]"
+		  << std::endl;
+	exit(1);
+}
+
+void parse_args_and_init(int argc, char **argv, UpdaterAppState *app_state)
+{
+	int i;
+
+	for (i = 1; i < argc; i++)
+	{
+		if ((!strcmp(argv[i], "--url")) && (++i < argc))
+		{
+			app_state->url = argv[i];
+		}
+		else if ((!strcmp(argv[i], "--file")) && (++i < argc))
+		{
+			app_state->file = argv[i];
+		}
+		else if ((!strcmp(argv[i], "--name")) && (++i < argc))
+		{
+			app_state->app_name = argv[i];
+		}
+		else if ((!strcmp(argv[i], "--image-dir")) && (++i < argc))
+		{
+			app_state->image_dir = argv[i];
+			app_state->image_dir_iter = new LLDirIterator(argv[i], "*.jpg");
+		}
+		else if ((!strcmp(argv[i], "--dest")) && (++i < argc))
+		{
+			app_state->dest_dir = argv[i];
+		}
+		else if ((!strcmp(argv[i], "--stringsdir")) && (++i < argc))
+		{
+			app_state->strings_dirs = argv[i];
+		}
+		else if ((!strcmp(argv[i], "--stringsfile")) && (++i < argc))
+		{
+			app_state->strings_file = argv[i];
+		}
+		else
+		{
+			// show usage, an invalid option was given.
+			show_usage_and_exit();
+		}
+	}
+
+	if (app_state->app_name.empty()
+	    || (app_state->url.empty() && app_state->file.empty())
+	    || app_state->dest_dir.empty())
+	{
+		show_usage_and_exit();
+	}
+
+	app_state->progress_value = 0.0;
+	app_state->activity_mode = FALSE;
+	app_state->failure = FALSE;
+
+	translate_init(app_state->strings_dirs, app_state->strings_file);
+}
+
+int main(int argc, char **argv)
+{
+	UpdaterAppState* app_state = new UpdaterAppState;
+
+	parse_args_and_init(argc, argv, app_state);
+
+	// Initialize logger, and rename old log file
+	gDirUtilp->initAppDirs("SecondLife");
+	LLError::initForApplication
+		(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, ""));
+	std::string old_log_file = gDirUtilp->getExpandedFilename
+		(LL_PATH_LOGS, "updater.log.old");
+	std::string log_file =
+		gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "updater.log");
+	LLFile::rename(log_file, old_log_file);
+	LLError::logToFile(log_file);
+
+	// initialize gthreads and gtk+
+	if (!g_thread_supported())
+	{
+		g_thread_init(NULL);
+		gdk_threads_init();
+	}
+
+	gtk_init(&argc, &argv);
+
+	// create UI
+	updater_app_ui_init(app_state);
+
+	//llinfos << "SAMPLE TRANSLATION IS: " << LLTrans::getString("LoginInProgress") << llendl;
+
+	// create download thread
+	g_thread_create(GThreadFunc(worker_thread_cb), app_state, FALSE, NULL);
+
+	gdk_threads_enter();
+	gtk_main();
+	gdk_threads_leave();
+
+	// Delete the file only if created from url download.
+	if(!app_state->url.empty() && !app_state->file.empty())
+	{
+		if (gDirUtilp->fileExists(app_state->file))
+		{
+			LLFile::remove(app_state->file);
+		}
+	}
+
+	bool success = !app_state->failure;
+	delete app_state->image_dir_iter;
+	delete app_state;
+	return success ? 0 : 1;
+}
+
+/*****************************************************************************
+*   Dummy LLTrans implementation (IQA-490)
+*****************************************************************************/
+static LLTrans sStaticStrings;
+
+// lookup
+std::string LLTrans::_getString(const std::string& key) const
+{
+	MessageMap::const_iterator found = mMessages.find(key);
+	if (found != mMessages.end())
+	{
+		return found->second;
+	}
+	LL_WARNS("linux_updater") << "No message for key '" << key
+							  << "' -- add to LLTrans::LLTrans() in linux_updater.cpp"
+							  << LL_ENDL;
+	return key;
+}
+
+// static lookup
+std::string LLTrans::getString(const std::string& key)
+{
+    return sLLTransInstance._getString(key);
+}
+
+// initialization
+LLTrans::LLTrans()
+{
+	typedef std::pair<const char*, const char*> Pair;
+	static const Pair data[] =
+	{
+		Pair("UpdaterFailDownloadTitle",
+			 "Failed to download update"),
+		Pair("UpdaterFailInstallTitle",
+			 "Failed to install update"),
+		Pair("UpdaterFailStartTitle",
+			 "Failed to start viewer"),
+		Pair("UpdaterFailUpdateDescriptive",
+			 "An error occurred while updating Second Life. "
+			 "Please download the latest version from www.secondlife.com."),
+		Pair("UpdaterNowInstalling",
+			 "Installing Second Life..."),
+		Pair("UpdaterNowUpdating",
+			 "Now updating Second Life..."),
+		Pair("UpdaterProgressBarText",
+			 "Downloading update"),
+		Pair("UpdaterProgressBarTextWithEllipses",
+			 "Downloading update..."),
+		Pair("UpdaterUpdatingDescriptive",
+			 "Your Second Life Viewer is being updated to the latest release. "
+			 "This may take some time, so please be patient."),
+		Pair("UpdaterWindowTitle",
+			 "Second Life Update")
+	};
+
+	BOOST_FOREACH(Pair pair, data)
+	{
+		mMessages[pair.first] = pair.second;
+	}
+}
--- a/indra/llappearance/llpolyskeletaldistortion.h
+++ b/indra/llappearance/llpolyskeletaldistortion.h
@ -63,6 +63,7 @@ struct LLPolySkeletalBoneInfo
 	BOOL mHasPositionDeformation;
 };

+LL_ALIGN_PREFIX(16)
 class LLPolySkeletalDistortionInfo : public LLViewerVisualParamInfo
 {
 	friend class LLPolySkeletalDistortion;
@ -118,13 +119,13 @@ public:
 	/*virtual*/ const LLVector4a*	getNextDistortion(U32 *index, LLPolyMesh **poly_mesh){index = 0; poly_mesh = NULL; return NULL;};

 protected:
+	LL_ALIGN_16(LLVector4a mDefaultVec);
 	typedef std::map<LLJoint*, LLVector3> joint_vec_map_t;
 	joint_vec_map_t mJointScales;
 	joint_vec_map_t mJointOffsets;
-	LLVector4a	mDefaultVec;
 	// Backlink only; don't make this an LLPointer.
 	LLAvatarAppearance *mAvatar;
-};
+} LL_ALIGN_POSTFIX(16);

 #endif // LL_LLPOLYSKELETALDISTORTION_H

--- a/indra/llappearance/lltexlayer.cpp
+++ b/indra/llappearance/lltexlayer.cpp
@ -150,6 +150,10 @@ BOOL LLTexLayerSetBuffer::renderTexLayerSet()
 		gAlphaMaskProgram.bind();
 		gAlphaMaskProgram.setMinimumAlpha(0.004f);
 	}
+	else
+	{
+		gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.00f);
+	}

 	LLVertexBuffer::unbind();

@ -928,7 +932,45 @@ LLWearableType::EType LLTexLayerInterface::getWearableType() const
 	ETextureIndex te = getLocalTextureIndex();
 	if (TEX_INVALID == te)
 	{
-		return LLWearableType::WT_INVALID;
+		LLWearableType::EType type = LLWearableType::WT_INVALID;
+		param_color_list_t::const_iterator color_iter = mParamColorList.begin();
+		param_alpha_list_t::const_iterator alpha_iter = mParamAlphaList.begin();
+
+		for (; color_iter != mParamColorList.end(); color_iter++)
+		{
+			LLTexLayerParamColor* param = *color_iter;
+			if (param) 
+			{
+				LLWearableType::EType new_type = (LLWearableType::EType)param->getWearableType();
+				if (new_type != LLWearableType::WT_INVALID && new_type != type) 
+				{
+					if (type != LLWearableType::WT_INVALID) 
+					{
+						return LLWearableType::WT_INVALID;
+					}
+					type = new_type;
+				}
+			}
+		}
+
+		for (; alpha_iter != mParamAlphaList.end(); alpha_iter++)
+		{
+			LLTexLayerParamAlpha* param = *alpha_iter;
+			if (param) 
+			{
+				LLWearableType::EType new_type = (LLWearableType::EType)param->getWearableType();
+				if (new_type != LLWearableType::WT_INVALID && new_type != type) 
+				{
+					if (type != LLWearableType::WT_INVALID) 
+					{
+						return LLWearableType::WT_INVALID;
+					}
+					type = new_type;
+				}
+			}
+		}
+
+		return type;
 	}
 	return LLAvatarAppearanceDictionary::getTEWearableType(te);
 }
@ -1132,7 +1174,8 @@ BOOL LLTexLayer::render(S32 x, S32 y, S32 width, S32 height)
 			}
 		}//*/

-		renderMorphMasks(x, y, width, height, net_color);
+		const bool force_render = true;
+		renderMorphMasks(x, y, width, height, net_color, force_render);
 		alpha_mask_specified = TRUE;
 		gGL.flush();
 		gGL.blendFunc(LLRender::BF_DEST_ALPHA, LLRender::BF_ONE_MINUS_DEST_ALPHA);
@ -1381,8 +1424,13 @@ BOOL LLTexLayer::blendAlphaTexture(S32 x, S32 y, S32 width, S32 height)
 }

 static LLFastTimer::DeclareTimer FTM_RENDER_MORPH_MASKS("renderMorphMasks");
-BOOL LLTexLayer::renderMorphMasks(S32 x, S32 y, S32 width, S32 height, const LLColor4 &layer_color)
+void LLTexLayer::renderMorphMasks(S32 x, S32 y, S32 width, S32 height, const LLColor4 &layer_color, bool force_render)
 {
+	if (!force_render && !hasMorph())
+	{
+		lldebugs << "skipping renderMorphMasks for " << getUUID() << llendl;
+		return;
+	}
 	LLFastTimer t(FTM_RENDER_MORPH_MASKS);
 	BOOL success = TRUE;

@ -1419,6 +1467,11 @@ BOOL LLTexLayer::renderMorphMasks(S32 x, S32 y, S32 width, S32 height, const LLC
 	{
 		LLTexLayerParamAlpha* param = *iter;
 		success &= param->render( x, y, width, height );
+		if (!success && !force_render)
+		{
+			lldebugs << "Failed to render param " << param->getID() << " ; skipping morph mask." << llendl;
+			return;
+		}
 	}

 	// Approximates a min() function
@ -1444,25 +1497,29 @@ BOOL LLTexLayer::renderMorphMasks(S32 x, S32 y, S32 width, S32 height, const LLC
 		}
 	}

-	if( !getInfo()->mStaticImageFileName.empty() )
+	if( !getInfo()->mStaticImageFileName.empty() && getInfo()->mStaticImageIsMask )
 	{
 		LLGLTexture* tex = LLTexLayerStaticImageList::getInstance()->getTexture(getInfo()->mStaticImageFileName, getInfo()->mStaticImageIsMask);
 		if( tex )
 		{
-			if(	(tex->getComponents() == 4) ||
-				( (tex->getComponents() == 1) && getInfo()->mStaticImageIsMask ) )
+			if(	(tex->getComponents() == 4) || (tex->getComponents() == 1) )
 			{
 				LLGLSNoAlphaTest gls_no_alpha_test;
 				gGL.getTexUnit(0)->bind(tex, TRUE);
 				gl_rect_2d_simple_tex( width, height );
 				gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
 			}
+			else
+			{
+				llwarns << "Skipping rendering of " << getInfo()->mStaticImageFileName 
+						<< "; expected 1 or 4 components." << llendl;
+			}
 		}
 	}

 	// Draw a rectangle with the layer color to multiply the alpha by that color's alpha.
 	// Note: we're still using gGL.blendFunc( GL_DST_ALPHA, GL_ZERO );
-	if (layer_color.mV[VW] != 1.f)
+	if ( !is_approx_equal(layer_color.mV[VW], 1.f) )
 	{
 		LLGLDisable no_alpha(GL_ALPHA_TEST);
 		gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
@ -1515,8 +1572,6 @@ BOOL LLTexLayer::renderMorphMasks(S32 x, S32 y, S32 width, S32 height, const LLC
 		mMorphMasksValid = TRUE;
 		getTexLayerSet()->applyMorphMask(alpha_data, width, height, 1);
 	}
-
-	return success;
 }

 static LLFastTimer::DeclareTimer FTM_ADD_ALPHA_MASK("addAlphaMask");
@ -1531,7 +1586,8 @@ void LLTexLayer::addAlphaMask(U8 *data, S32 originX, S32 originY, S32 width, S32
 		findNetColor( &net_color );
 		// TODO: eliminate need for layer morph mask valid flag
 		invalidateMorphMasks();
-		renderMorphMasks(originX, originY, width, height, net_color);
+		const bool force_render = false;
+		renderMorphMasks(originX, originY, width, height, net_color, force_render);
 		alphaData = getAlphaData();
 	}
 	if (alphaData)
@ -1540,7 +1596,7 @@ void LLTexLayer::addAlphaMask(U8 *data, S32 originX, S32 originY, S32 width, S32
 		{
 			U8 curAlpha = data[i];
 			U16 resultAlpha = curAlpha;
-			resultAlpha *= (alphaData[i] + 1);
+			resultAlpha *= ( ((U16)alphaData[i]) + 1);
 			resultAlpha = resultAlpha >> 8;
 			data[i] = (U8)resultAlpha;
 		}
@ -1915,9 +1971,15 @@ LLGLTexture* LLTexLayerStaticImageList::getTexture(const std::string& file_name,
 		{
 			if( (image_raw->getComponents() == 1) && is_mask )
 			{
-				// Note: these are static, unchanging images so it's ok to assume
-				// that once an image is a mask it's always a mask.
-				tex->setExplicitFormat( GL_ALPHA8, GL_ALPHA );
+				// Convert grayscale alpha masks from single channel into RGBA.
+				// Fill RGB with black to allow fixed function gl calls
+				// to match shader implementation.
+				LLPointer<LLImageRaw> alpha_image_raw = image_raw;
+				image_raw = new LLImageRaw(image_raw->getWidth(),
+										   image_raw->getHeight(),
+										   4);
+
+				image_raw->copyUnscaledAlphaMask(alpha_image_raw, LLColor4U::black);
 			}
 			tex->createGLTexture(0, image_raw, 0, TRUE, LLGLTexture::LOCAL);

--- a/indra/llappearance/lltexlayer.h
+++ b/indra/llappearance/lltexlayer.h
@ -160,7 +160,7 @@ public:
 	BOOL					findNetColor(LLColor4* color) const;
 	/*virtual*/ BOOL		blendAlphaTexture(S32 x, S32 y, S32 width, S32 height); // Multiplies a single alpha texture against the frame buffer
 	/*virtual*/ void		gatherAlphaMasks(U8 *data, S32 originX, S32 originY, S32 width, S32 height);
-	BOOL					renderMorphMasks(S32 x, S32 y, S32 width, S32 height, const LLColor4 &layer_color);
+	void					renderMorphMasks(S32 x, S32 y, S32 width, S32 height, const LLColor4 &layer_color, bool force_render);
 	void					addAlphaMask(U8 *data, S32 originX, S32 originY, S32 width, S32 height);
 	/*virtual*/ BOOL		isInvisibleAlphaMask() const;

--- a/indra/llappearance/llwearable.cpp
+++ b/indra/llappearance/llwearable.cpp
@ -191,7 +191,7 @@ LLWearable::EImportResult LLWearable::importStream( std::istream& input_stream,
 	// We are using a local max buffer size here to avoid issues
 	// if MAX_STRING size changes.
 	const U32 PARSE_BUFFER_SIZE = 2048;
-	char buffer[2048];		/* Flawfinder: ignore */
+	char buffer[PARSE_BUFFER_SIZE];		/* Flawfinder: ignore */
 	char uuid_buffer[37];	/* Flawfinder: ignore */

 	// This data is being generated on the viewer.
@ -205,12 +205,11 @@ LLWearable::EImportResult LLWearable::importStream( std::istream& input_stream,
 	}

 	// read header and version 
-	if (!input_stream.good())
+	if (!getNextPopulatedLine(input_stream, buffer, PARSE_BUFFER_SIZE))
 	{
 		llwarns << "Failed to read wearable asset input stream." << llendl;
 		return LLWearable::FAILURE;
 	}
-	input_stream.getline(buffer, PARSE_BUFFER_SIZE);
 	if ( 1 != sscanf( /* Flawfinder: ignore */
 				buffer,
 				"LLWearable version %d\n",
@ -230,8 +229,8 @@ LLWearable::EImportResult LLWearable::importStream( std::istream& input_stream,
 		return LLWearable::FAILURE;
 	}

-	// name
-	if (!input_stream.good())
+	// name may be empty
+    if (!input_stream.good())
 	{
 		llwarns << "Bad Wearable asset: early end of input stream " 
 				<< "while reading name" << llendl;
@ -240,7 +239,7 @@ LLWearable::EImportResult LLWearable::importStream( std::istream& input_stream,
 	input_stream.getline(buffer, PARSE_BUFFER_SIZE);
 	mName = buffer;

-	// description
+	// description may be empty
 	if (!input_stream.good())
 	{
 		llwarns << "Bad Wearable asset: early end of input stream " 
@ -250,14 +249,13 @@ LLWearable::EImportResult LLWearable::importStream( std::istream& input_stream,
 	input_stream.getline(buffer, PARSE_BUFFER_SIZE);
 	mDescription = buffer;

-	// permissions
-	if (!input_stream.good())
+	// permissions may have extra empty lines before the correct line
+	if (!getNextPopulatedLine(input_stream, buffer, PARSE_BUFFER_SIZE))
 	{
 		llwarns << "Bad Wearable asset: early end of input stream " 
 				<< "while reading permissions" << llendl;
 		return LLWearable::FAILURE;
 	}
-	input_stream.getline(buffer, PARSE_BUFFER_SIZE);
 	S32 perm_version = -1;
 	if ( 1 != sscanf( buffer, " permissions %d\n", &perm_version ) ||
 		 perm_version != 0 )
@ -271,13 +269,12 @@ LLWearable::EImportResult LLWearable::importStream( std::istream& input_stream,
 	}

 	// sale info
-	if (!input_stream.good())
+	if (!getNextPopulatedLine(input_stream, buffer, PARSE_BUFFER_SIZE))
 	{
 		llwarns << "Bad Wearable asset: early end of input stream " 
 				<< "while reading sale info" << llendl;
 		return LLWearable::FAILURE;
 	}
-	input_stream.getline(buffer, PARSE_BUFFER_SIZE);
 	S32 sale_info_version = -1;
 	if ( 1 != sscanf( buffer, " sale_info %d\n", &sale_info_version ) ||
 		sale_info_version != 0 )
@ -306,13 +303,12 @@ LLWearable::EImportResult LLWearable::importStream( std::istream& input_stream,
 	}

 	// wearable type
-	if (!input_stream.good())
+	if (!getNextPopulatedLine(input_stream, buffer, PARSE_BUFFER_SIZE))
 	{
 		llwarns << "Bad Wearable asset: early end of input stream " 
 				<< "while reading type" << llendl;
 		return LLWearable::FAILURE;
 	}
-	input_stream.getline(buffer, PARSE_BUFFER_SIZE);
 	S32 type = -1;
 	if ( 1 != sscanf( buffer, "type %d\n", &type ) )
 	{
@ -331,13 +327,12 @@ LLWearable::EImportResult LLWearable::importStream( std::istream& input_stream,
 	}

 	// parameters header
-	if (!input_stream.good())
+	if (!getNextPopulatedLine(input_stream, buffer, PARSE_BUFFER_SIZE))
 	{
 		llwarns << "Bad Wearable asset: early end of input stream " 
 				<< "while reading parameters header" << llendl;
 		return LLWearable::FAILURE;
 	}
-	input_stream.getline(buffer, PARSE_BUFFER_SIZE);
 	S32 num_parameters = -1;
 	if ( 1 != sscanf( buffer, "parameters %d\n", &num_parameters ) )
 	{
@ -363,13 +358,12 @@ LLWearable::EImportResult LLWearable::importStream( std::istream& input_stream,
 	S32 i;
 	for( i = 0; i < num_parameters; i++ )
 	{
-		if (!input_stream.good())
+		if (!getNextPopulatedLine(input_stream, buffer, PARSE_BUFFER_SIZE))
 		{
 			llwarns << "Bad Wearable asset: early end of input stream " 
 					<< "while reading parameter #" << i << llendl;
 			return LLWearable::FAILURE;
 		}
-		input_stream.getline(buffer, PARSE_BUFFER_SIZE);
 		S32 param_id = 0;
 		F32 param_weight = 0.f;
 		if ( 2 != sscanf( buffer, "%d %f\n", &param_id, &param_weight ) )
@ -381,13 +375,12 @@ LLWearable::EImportResult LLWearable::importStream( std::istream& input_stream,
 	}

 	// textures header
-	if (!input_stream.good())
+	if (!getNextPopulatedLine(input_stream, buffer, PARSE_BUFFER_SIZE))
 	{
 		llwarns << "Bad Wearable asset: early end of input stream " 
 				<< "while reading textures header" << i << llendl;
 		return LLWearable::FAILURE;
 	}
-	input_stream.getline(buffer, PARSE_BUFFER_SIZE);
 	S32 num_textures = -1;
 	if ( 1 != sscanf( buffer, "textures %d\n", &num_textures) )
 	{
@ -404,13 +397,12 @@ LLWearable::EImportResult LLWearable::importStream( std::istream& input_stream,
 	// textures
 	for( i = 0; i < num_textures; i++ )
 	{
-		if (!input_stream.good())
+		if (!getNextPopulatedLine(input_stream, buffer, PARSE_BUFFER_SIZE))
 		{
 			llwarns << "Bad Wearable asset: early end of input stream " 
 					<< "while reading textures #" << i << llendl;
 			return LLWearable::FAILURE;
 		}
-		input_stream.getline(buffer, PARSE_BUFFER_SIZE);
 		S32 te = 0;
 		if ( 2 != sscanf(   /* Flawfinder: ignore */
 				buffer,
@ -450,6 +442,22 @@ LLWearable::EImportResult LLWearable::importStream( std::istream& input_stream,
 	return LLWearable::SUCCESS;
 }

+BOOL LLWearable::getNextPopulatedLine(std::istream& input_stream, char* buffer, U32 buffer_size)
+{
+	if (!input_stream.good())
+	{
+		return FALSE;
+	}
+
+	do 
+	{
+		input_stream.getline(buffer, buffer_size);
+	}
+	while (input_stream.good() && buffer[0]=='\0');
+
+	return input_stream.good(); 
+}
+

 void LLWearable::setType(LLWearableType::EType type, LLAvatarAppearance *avatarp) 
 { 
--- a/indra/llappearance/llwearable.h
+++ b/indra/llappearance/llwearable.h
@ -119,6 +119,7 @@ protected:
 	void				destroyTextures();
 	void			 	createVisualParams(LLAvatarAppearance *avatarp);
 	void 				createLayers(S32 te, LLAvatarAppearance *avatarp);
+	BOOL				getNextPopulatedLine(std::istream& input_stream, char* buffer, U32 buffer_size);

 	static S32			sCurrentDefinitionVersion;	// Depends on the current state of the avatar_lad.xml.
 	S32					mDefinitionVersion;			// Depends on the state of the avatar_lad.xml when this asset was created.
--- a/indra/llcommon/llfasttimer.cpp
+++ b/indra/llcommon/llfasttimer.cpp
@ -582,6 +582,12 @@ std::vector<LLFastTimer::NamedTimer*>& LLFastTimer::NamedTimer::getChildren()
 	return mChildren;
 }

+// static
+LLFastTimer::NamedTimer& LLFastTimer::NamedTimer::getRootNamedTimer()
+{
+        return *NamedTimerFactory::instance().getRootTimer();
+}
+
 //static
 void LLFastTimer::nextFrame()
 {
--- a/indra/llcommon/llfasttimer.h
+++ b/indra/llcommon/llfasttimer.h
@ -91,6 +91,8 @@ public:
 		U32 getHistoricalCount(S32 history_index = 0) const;
 		U32 getHistoricalCalls(S32 history_index = 0) const;

+		static NamedTimer& getRootNamedTimer();
+
 		void setFrameState(FrameState* state) { mFrameState = state; state->setNamedTimer(this); }
 		FrameState& getFrameState() const;

--- a/indra/llimage/llimage.cpp
+++ b/indra/llimage/llimage.cpp
@ -659,6 +659,29 @@ void LLImageRaw::compositeUnscaled4onto3( LLImageRaw* src )
 	}
 }

+void LLImageRaw::copyUnscaledAlphaMask( LLImageRaw* src, const LLColor4U& fill)
+{
+	LLImageRaw* dst = this;  // Just for clarity.
+
+	llassert( 1 == src->getComponents() );
+	llassert( 4 == dst->getComponents() );
+	llassert( (src->getWidth() == dst->getWidth()) && (src->getHeight() == dst->getHeight()) );
+
+	S32 pixels = getWidth() * getHeight();
+	U8* src_data = src->getData();
+	U8* dst_data = dst->getData();
+	for ( S32 i = 0; i < pixels; i++ )
+	{
+		dst_data[0] = fill.mV[0];
+		dst_data[1] = fill.mV[1];
+		dst_data[2] = fill.mV[2];
+		dst_data[3] = src_data[0];
+		src_data += 1;
+		dst_data += 4;
+	}
+}
+
+
 // Fill the buffer with a constant color
 void LLImageRaw::fill( const LLColor4U& color )
 {
--- a/indra/llimage/llimage.h
+++ b/indra/llimage/llimage.h
@ -233,6 +233,11 @@ public:
 	// Src and dst are same size.  Src has 3 components.  Dst has 4 components.
 	void copyUnscaled3onto4( LLImageRaw* src );

+	// Src and dst are same size.  Src has 1 component.  Dst has 4 components.
+	// Alpha component is set to source alpha mask component.
+	// RGB components are set to fill color.
+	void copyUnscaledAlphaMask( LLImageRaw* src, const LLColor4U& fill);
+
 	// Src and dst can be any size.  Src and dst have same number of components.
 	void copyScaled( LLImageRaw* src );

--- a/indra/llinventory/CMakeLists.txt
+++ b/indra/llinventory/CMakeLists.txt
@ -21,6 +21,10 @@ include_directories(SYSTEM
    ${LLCOMMON_SYSTEM_INCLUDE_DIRS}
    ${LLXML_SYSTEM_INCLUDE_DIRS}
    )
+include_directories(SYSTEM
+    ${LLCOMMON_SYSTEM_INCLUDE_DIRS}
+    ${LLXML_SYSTEM_INCLUDE_DIRS}
+    )

 set(llinventory_SOURCE_FILES
    llcategory.cpp
--- a/indra/llinventory/llinventory.cpp
+++ b/indra/llinventory/llinventory.cpp
@ -379,6 +379,11 @@ const std::string& LLInventoryItem::getDescription() const
 	return mDescription;
 }

+const std::string& LLInventoryItem::getActualDescription() const
+{
+	return mDescription;
+}
+
 time_t LLInventoryItem::getCreationDate() const
 {
 	return mCreationDate;
--- a/indra/llinventory/llinventory.h
+++ b/indra/llinventory/llinventory.h
@ -157,6 +157,7 @@ public:
 	virtual const LLUUID& getCreatorUUID() const;
 	virtual const LLUUID& getAssetUUID() const;
 	virtual const std::string& getDescription() const;
+	virtual const std::string& getActualDescription() const; // Does not follow links
 	virtual const LLSaleInfo& getSaleInfo() const;
 	virtual LLInventoryType::EType getInventoryType() const;
 	virtual U32 getFlags() const;
--- a/indra/llprimitive/CMakeLists.txt
+++ b/indra/llprimitive/CMakeLists.txt
@ -19,6 +19,10 @@ include_directories(
    # ${LIBS_PREBUILT_DIR}/include/collada/1.4
    ${COLLADA_INCLUDE_DIRS}
    )
+include_directories(SYSTEM
+    ${LLCOMMON_SYSTEM_INCLUDE_DIRS}
+    ${LLXML_SYSTEM_INCLUDE_DIRS}
+    )
 include_directories(SYSTEM
    ${LLCOMMON_SYSTEM_INCLUDE_DIRS}
    ${LLXML_SYSTEM_INCLUDE_DIRS}
--- a/indra/llprimitive/llprimitive.cpp
+++ b/indra/llprimitive/llprimitive.cpp
@ -1254,6 +1254,7 @@ S32 LLPrimitive::parseTEMessage(LLMessageSystem* mesgsys, char const* block_name

 	if (tec.size == 0)
 	{
+		tec.face_count = 0;
 		return retval;
 	}

--- a/indra/llrender/llgltexture.h
+++ b/indra/llrender/llgltexture.h
@ -79,6 +79,15 @@ public:
 		MAX_GL_IMAGE_CATEGORY
 	};

+	typedef enum 
+	{
+		DELETED = 0,         //removed from memory
+		DELETION_CANDIDATE,  //ready to be removed from memory
+		INACTIVE,            //not be used for the last certain period (i.e., 30 seconds).
+		ACTIVE,              //just being used, can become inactive if not being used for a certain time (10 seconds).
+		NO_DELETE = 99       //stay in memory, can not be removed.
+	} LLGLTextureState;
+
 	static S32 getTotalNumOfCategories() ;
 	static S32 getIndexFromCategory(S32 category) ;
 	static S32 getCategoryFromIndex(S32 index) ;
@ -143,6 +152,8 @@ public:
 	U32        getTexelsInGLTexture() const ;
 	BOOL       isGLTextureCreated() const ;
 	S32        getDiscardLevelInAtlas() const ;
+	LLGLTextureState getTextureState() const { return mTextureState; }
+	
 	//---------------------------------------------------------------------------------------------
 	//end of functions to access LLImageGL
 	//---------------------------------------------------------------------------------------------
@ -179,14 +190,6 @@ protected:
 	S8 mDontDiscard;			// Keep full res version of this image (for UI, etc)

 protected:
-	typedef enum 
-	{
-		DELETED = 0,         //removed from memory
-		DELETION_CANDIDATE,  //ready to be removed from memory
-		INACTIVE,            //not be used for the last certain period (i.e., 30 seconds).
-		ACTIVE,              //just being used, can become inactive if not being used for a certain time (10 seconds).
-		NO_DELETE = 99       //stay in memory, can not be removed.
-	} LLGLTextureState;
 	LLGLTextureState  mTextureState ;


--- a/indra/llui/CMakeLists.txt
+++ b/indra/llui/CMakeLists.txt
@ -31,6 +31,10 @@ include_directories(SYSTEM
    ${LLCOMMON_SYSTEM_INCLUDE_DIRS}
    ${LLXML_SYSTEM_INCLUDE_DIRS}
    )
+include_directories(SYSTEM
+    ${LLCOMMON_SYSTEM_INCLUDE_DIRS}
+    ${LLXML_SYSTEM_INCLUDE_DIRS}
+    )

 set(llui_SOURCE_FILES
    llaccordionctrl.cpp
--- a/indra/llui/llui.h
+++ b/indra/llui/llui.h
@ -508,8 +508,4 @@ namespace LLInitParam
 	};
 }

-extern LLGLSLShader gSolidColorProgramIntel;
-
-// <FS:ND> FIRE-6855; Solidcolor shader for Intel graphics
-// </FS:ND>
 #endif
--- a/indra/mac_crash_logger/CrashReporter.nib
+++ b/indra/mac_crash_logger/CrashReporter.nib
--- a/indra/newview/CMakeLists.txt
+++ b/indra/newview/CMakeLists.txt
@ -1779,7 +1779,7 @@ if (WINDOWS)
        # *TODO -reenable this once we get server usage sorted out
        LINK_FLAGS "/debug /NODEFAULTLIB:LIBCMT /SUBSYSTEM:WINDOWS ${TCMALLOC_LINK_FLAGS} /LARGEADDRESSAWARE"
        LINK_FLAGS_DEBUG "/NODEFAULTLIB:\"LIBCMT;LIBCMTD;MSVCRT\" /INCREMENTAL:NO /LARGEADDRESSAWARE"
-        LINK_FLAGS_RELEASE "/FORCE:MULTIPLE /MAP\"secondlife-bin.MAP\" /OPT:REF /LARGEADDRESSAWARE"
+        LINK_FLAGS_RELEASE "/MAP\"secondlife-bin.MAP\" /OPT:REF /LARGEADDRESSAWARE"
        )
    if(USE_PRECOMPILED_HEADERS)
        set_target_properties(
@ -2302,6 +2302,15 @@ if (LL_TESTS)
    #llviewertexturelist.cpp
  )

+  set_source_files_properties(
+    llworldmap.cpp
+    llworldmipmap.cpp
+    PROPERTIES
+    LL_TEST_ADDITIONAL_SOURCE_FILES 
+    tests/llviewertexture_stub.cpp
+    #llviewertexturelist.cpp
+  )
+
  set_source_files_properties(
    lltranslate.cpp
    PROPERTIES
--- a/indra/newview/app_settings/logcontrol.xml
+++ b/indra/newview/app_settings/logcontrol.xml
@ -42,9 +42,10 @@
 						</array>
 					<key>tags</key>
 						<array>
-						<!-- sample entry for debugging specific items	
 						     <string>Avatar</string>
-						     <string>Voice</string> -->
+						<!-- sample entry for debugging specific items	
+						     <string>Voice</string>		
+						-->
 						     <string>parseFile</string>
 						</array>
 				</map>
--- a/indra/newview/app_settings/settings.xml
+++ b/indra/newview/app_settings/settings.xml
@ -3681,6 +3681,17 @@
      <integer>0</integer>
    </map>
  <key>DebugAvatarAppearanceMessage</key>
+  <map>
+    <key>Comment</key>
+    <string>Dump a bunch of XML files when handling appearance messages</string>
+    <key>Persist</key>
+    <integer>1</integer>
+    <key>Type</key>
+    <string>Boolean</string>
+    <key>Value</key>
+    <integer>0</integer>
+  </map>
+  <key>DebugAvatarAppearanceMessage</key>
  <map>
    <key>Comment</key>
    <string>Dump a bunch of XML files when handling appearance messages</string>
@ -3718,6 +3729,17 @@
    <integer>0</integer>
  </map>
  <key>DebugAvatarCompositeBaked</key>
+  <map>
+    <key>Comment</key>
+    <string>Colorize avatar meshes based on baked/composite state.</string>
+    <key>Persist</key>
+    <integer>1</integer>
+    <key>Type</key>
+    <string>Boolean</string>
+    <key>Value</key>
+    <integer>0</integer>
+  </map>
+  <key>DebugAvatarCompositeBaked</key>
  <map>
    <key>Comment</key>
    <string>Colorize avatar meshes based on baked/composite state.</string>
@ -5831,7 +5853,6 @@
      <key>Value</key>
      <real>96.0</real>
    </map>
-
    <key>ForceAssetFail</key>
    <map>
      <key>Comment</key>
@ -5854,9 +5875,7 @@
      <key>Type</key>
      <string>F32</string>
      <key>Value</key>
-      <real>0.0</real>
-      <key>Backup</key>
-      <integer>0</integer>
+      <integer>0.0</integer>
    </map>
    <key>ForceShowGrid</key>
    <map>
@ -5867,6 +5886,8 @@
      <key>Type</key>
      <string>Boolean</string>
      <key>Value</key>
+      <real>0.0</real>
+      <key>Backup</key>
      <integer>0</integer>
    </map>
    <key>ForceMandatoryUpdate</key>
@ -5879,8 +5900,6 @@
      <string>Boolean</string>
      <key>Value</key>
      <integer>0</integer>
-      <key>Backup</key>
-      <integer>0</integer>
    </map>
    <key>ForceMissingType</key>
    <map>
@ -5892,8 +5911,6 @@
      <string>U32</string>
      <key>Value</key>
      <integer>255</integer>
-      <key>Backup</key>
-      <integer>0</integer>
    </map>
    <key>FreezeTime</key>
    <map>
@ -5906,6 +5923,28 @@
      <key>Value</key>
      <integer>0</integer>
    </map>
+    <key>FullScreenAspectRatio</key>
+    <map>
+      <key>Comment</key>
+      <string>Aspect ratio of fullscreen display (width / height)</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>F32</string>
+      <key>Value</key>
+      <real>3</real>
+    </map>
+    <key>FullScreenAutoDetectAspectRatio</key>
+    <map>
+      <key>Comment</key>
+      <string>Automatically detect proper aspect ratio for fullscreen display</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>0</integer>
+    </map>
    <key>GesturesMarketplaceURL</key>
    <map>
      <key>Comment</key>
@ -5915,7 +5954,7 @@
      <key>Type</key>
      <string>String</string>
      <key>Value</key>
-      <string>https://marketplace.secondlife.com/products/search?search[category_id]=200&amp;search[page]=1&amp;search[per_page]=12</string>
+      <string>https://marketplace.secondlife.com/products/search?search[category_id]=200&amp;search[maturity][]=General&amp;search[page]=1&amp;search[per_page]=12</string>
    </map>
    <key>GridCrossSections</key>
    <map>
@ -6264,6 +6303,17 @@
      <key>Value</key>
        <real>0.0</real>
    </map>
+    <key>InventoryDebugSimulateLateOpRate</key>
+    <map>
+      <key>Comment</key>
+        <string>Rate at which we simulate late-completing copy/link requests in some operations</string>
+      <key>Persist</key>
+        <integer>1</integer>
+      <key>Type</key>
+        <string>F32</string>
+      <key>Value</key>
+        <real>0.0</real>
+    </map>
    <key>InventoryDisplayInbox</key>
    <map>
        <key>Comment</key>
@ -11254,6 +11304,28 @@ Change of this parameter will affect the layout of buttons in notification toast
      <key>Value</key>
      <integer>0</integer>
    </map>
+    <key>DisableAllRenderTypes</key>
+    <map>
+      <key>Comment</key>
+      <string>Disables all rendering types.</string>
+      <key>Persist</key>
+      <integer>0</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>0</integer>
+    </map>
+    <key>DisableAllRenderFeatures</key>
+    <map>
+      <key>Comment</key>
+      <string>Disables all rendering features.</string>
+      <key>Persist</key>
+      <integer>0</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>0</integer>
+    </map>
    <key>RenderHUDInSnapshot</key>
    <map>
      <key>Comment</key>
@ -12555,6 +12627,17 @@ Change of this parameter will affect the layout of buttons in notification toast
      <key>Value</key>
      <integer>1</integer>
    </map>
+    <key>NearbyListShowMap</key>
+    <map>
+      <key>Comment</key>
+      <string>Show/hide map above nearby people list</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>1</integer>
+    </map>
    <key>NearbyListShowIcons</key>
    <map>
      <key>Comment</key>
@ -15612,6 +15695,17 @@ Change of this parameter will affect the layout of buttons in notification toast
      <key>Backup</key>
      <integer>0</integer>
    </map>
+    <key>VerifyInitialWearables</key>
+    <map>
+      <key>Comment</key>
+      <string>Compares the initial wearables to the COF contents to determine which one to use for the intial outfit</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <boolean>0</boolean>
+    </map>
    <key>VertexShaderEnable</key>
    <map>
      <key>Comment</key>
@ -16242,6 +16336,28 @@ Change of this parameter will affect the layout of buttons in notification toast
      <key>Value</key>
      <integer>-1.0</integer>
    </map>
+    <key>MaxFPS</key>
+    <map>
+      <key>Comment</key>
+      <string>Yield some time to the local host if we reach a threshold framerate.</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>F32</string>
+      <key>Value</key>
+      <integer>-1.0</integer>
+    </map>
+    <key>ForcePeriodicRenderingTime</key>
+    <map>
+      <key>Comment</key>
+      <string>Periodically enable all rendering masks for a single frame.</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>F32</string>
+      <key>Value</key>
+      <integer>-1.0</integer>
+    </map>
    <key>ZoomDirect</key>
    <map>
      <key>Comment</key>
@ -17940,6 +18056,18 @@ Change of this parameter will affect the layout of buttons in notification toast
    <key>Value</key>
    <integer>0</integer>
  </map>
+
+  <key>DisablePrecacheDelayAfterTeleporting</key>
+  <map>
+    <key>Comment</key>
+    <string>Disables the artificial delay in the viewer that precaches some incoming assets</string>
+    <key>Persist</key>
+    <integer>0</integer>
+    <key>Type</key>
+    <string>Boolean</string>
+    <key>Value</key>
+    <integer>0</integer>
+  </map>
  
    <key>GroupMembersSortOrder</key>
    <map>
--- a/indra/newview/app_settings/shaders/class1/lighting/lightFullbrightWaterAlphaMaskF.glsl
+++ b/indra/newview/app_settings/shaders/class1/lighting/lightFullbrightWaterAlphaMaskF.glsl
@ -31,7 +31,7 @@ out vec4 frag_color;

 uniform float minimum_alpha;

-vec4 diffuseLookup(vec2 texcoord);
+/* vec4 diffuseLookup(vec2 texcoord); */

 vec3 fullbrightAtmosTransport(vec3 light);
 vec4 applyWaterFog(vec4 color);
--- a/indra/newview/app_settings/shaders/class1/lighting/lightFullbrightWaterF.glsl
+++ b/indra/newview/app_settings/shaders/class1/lighting/lightFullbrightWaterF.glsl
@ -32,7 +32,7 @@ out vec4 frag_color;
 VARYING vec4 vertex_color;
 VARYING vec2 vary_texcoord0;

-vec4 diffuseLookup(vec2 texcoord);
+/* vec4 diffuseLookup(vec2 texcoord); */

 vec3 fullbrightAtmosTransport(vec3 light);
 vec4 applyWaterFog(vec4 color);
--- a/indra/newview/linux_tools/wrapper.sh
+++ b/indra/newview/linux_tools/wrapper.sh
@ -48,6 +48,7 @@ if [ "`uname -m`" = "x86_64" ]; then
    echo '64-bit Linux detected.'
 fi

+
 ## Everything below this line is just for advanced troubleshooters.
 ##-------------------------------------------------------------------

@ -63,7 +64,15 @@ fi
 export SDL_VIDEO_X11_DGAMOUSE=0

 ## - Works around a problem with misconfigured 64-bit systems not finding GL
-export LIBGL_DRIVERS_PATH="${LIBGL_DRIVERS_PATH}":/usr/lib64/dri:/usr/lib32/dri:/usr/lib/dri
+I386_MULTIARCH="$(dpkg-architecture -ai386 -qDEB_HOST_MULTIARCH 2>/dev/null)"
+MULTIARCH_ERR=$?
+if [ $MULTIARCH_ERR -eq 0 ]; then
+    echo 'Multi-arch support detected.'
+    MULTIARCH_GL_DRIVERS="/usr/lib/${I386_MULTIARCH}/dri"
+    export LIBGL_DRIVERS_PATH="${LIBGL_DRIVERS_PATH}:${MULTIARCH_GL_DRIVERS}:/usr/lib64/dri:/usr/lib32/dri:/usr/lib/dri"
+else
+    export LIBGL_DRIVERS_PATH="${LIBGL_DRIVERS_PATH}:/usr/lib64/dri:/usr/lib32/dri:/usr/lib/dri"
+fi

 ## - The 'scim' GTK IM module widely crashes the viewer.  Avoid it.
 if [ "$GTK_IM_MODULE" = "scim" ]; then
--- a/indra/newview/llagent.cpp
+++ b/indra/newview/llagent.cpp
@ -929,12 +929,23 @@ void LLAgent::handleServerBakeRegionTransition(const LLUUID& region_id)
 {
 	llinfos << "called" << llendl;

+
+	// Old-style appearance entering a server-bake region.
 	if (isAgentAvatarValid() &&
 		!gAgentAvatarp->isUsingServerBakes() &&
 		(mRegionp->getCentralBakeVersion()>0))
 	{
+		llinfos << "update requested due to region transition" << llendl;
 		LLAppearanceMgr::instance().requestServerAppearanceUpdate();
 	}
+	// new-style appearance entering a non-bake region,
+	// need to check for existence of the baking service.
+	else if (isAgentAvatarValid() &&
+			 gAgentAvatarp->isUsingServerBakes() &&
+			 mRegionp->getCentralBakeVersion()==0)
+	{
+		gAgentAvatarp->checkForUnsupportedServerBakeAppearance();
+	}
 }

 //-----------------------------------------------------------------------------
@ -4809,30 +4820,85 @@ void LLAgent::requestLeaveGodMode()
 	sendReliableMessage();
 }

+extern void dump_visual_param(apr_file_t* file, LLVisualParam* viewer_param, F32 value);
+extern std::string get_sequential_numbered_file_name(const std::string& prefix,
+													 const std::string& suffix);
+
+// For debugging, trace agent state at times appearance message are sent out.
+void LLAgent::dumpSentAppearance(const std::string& dump_prefix)
+{
+	std::string outfilename = get_sequential_numbered_file_name(dump_prefix,".xml");
+
+	LLAPRFile outfile;
+	std::string fullpath = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,outfilename);
+	outfile.open(fullpath, LL_APR_WB );
+	apr_file_t* file = outfile.getFileHandle();
+	if (!file)
+	{
+		return;
+	}
+	else
+	{
+		LL_DEBUGS("Avatar") << "dumping sent appearance message to " << fullpath << llendl;
+	}
+
+	LLVisualParam* appearance_version_param = gAgentAvatarp->getVisualParam(11000);
+	if (appearance_version_param)
+	{
+		F32 value = appearance_version_param->getWeight();
+		dump_visual_param(file, appearance_version_param, value);
+	}
+	for (LLAvatarAppearanceDictionary::Textures::const_iterator iter = LLAvatarAppearanceDictionary::getInstance()->getTextures().begin();
+		 iter != LLAvatarAppearanceDictionary::getInstance()->getTextures().end();
+		 ++iter)
+	{
+		const ETextureIndex index = iter->first;
+		const LLAvatarAppearanceDictionary::TextureEntry *texture_dict = iter->second;
+		if (texture_dict->mIsBakedTexture)
+		{
+			LLTextureEntry* entry = gAgentAvatarp->getTE((U8) index);
+			const LLUUID& uuid = entry->getID();
+			apr_file_printf( file, "\t\t<texture te=\"%i\" uuid=\"%s\"/>\n", index, uuid.asString().c_str());
+		}
+	}
+}
+
 //-----------------------------------------------------------------------------
 // sendAgentSetAppearance()
 //-----------------------------------------------------------------------------
 void LLAgent::sendAgentSetAppearance()
 {
-	// FIXME DRANO - problems around new-style appearance in an old-style region.
-	// - does this get called?
-	// - need to change mUseServerBakes->FALSE in that case
-	// - need to call processAvatarAppearance as if server had returned this result?
-	// gAgentAvatarp->mUseServerBakes = FALSE;
-
 	if (gAgentQueryManager.mNumPendingQueries > 0) 
 	{
 		return;
 	}

-	if (!gAgentWearables.changeInProgress())
+	if (!isAgentAvatarValid() || (getRegion() && getRegion()->getCentralBakeVersion())) return;
+
+	// At this point we have a complete appearance to send and are in a non-baking region.
+	// DRANO FIXME
+	//gAgentAvatarp->setIsUsingServerBakes(FALSE);
+	S32 sb_count, host_count, both_count, neither_count;
+	gAgentAvatarp->bakedTextureOriginCounts(sb_count, host_count, both_count, neither_count);
+	if (both_count != 0 || neither_count != 0)
 	{
-		// Change is fully resolved, can close some open phases.
-		gAgentAvatarp->getPhases().stopPhase("process_initial_wearables_update");
-		gAgentAvatarp->getPhases().stopPhase("wear_inventory_category");
+		llwarns << "bad bake texture state " << sb_count << "," << host_count << "," << both_count << "," << neither_count << llendl;
+	}
+	if (sb_count != 0 && host_count == 0)
+	{
+		gAgentAvatarp->setIsUsingServerBakes(true);
+	}
+	else if (sb_count == 0 && host_count != 0)
+	{
+		gAgentAvatarp->setIsUsingServerBakes(false);
+	}
+	else if (sb_count + host_count > 0)
+	{
+		llwarns << "unclear baked texture state, not sending appearance" << llendl;
+		return;
 	}
 	
-	gAgentAvatarp->sendAppearanceChangeMetrics();
+

 	if (!isAgentAvatarValid() || (getRegion() && getRegion()->getCentralBakeVersion())) return;

@ -4853,7 +4919,7 @@ void LLAgent::sendAgentSetAppearance()
 //	const LLVector3 body_size = gAgentAvatarp->mBodySize;
 // [RLVa:KB] - Checked: 2010-10-11 (RLVa-1.2.0e) | Added: RLVa-1.2.0e
 	LLVector3 body_size = gAgentAvatarp->mBodySize;
-	body_size.mV[VZ] += gSavedPerAccountSettings.getF32("AvatarZOffset");
+	body_size.mV[VZ] += RlvSettings::getAvatarOffsetZ();
 // [/RLVa:KB]
 	msg->addVector3Fast(_PREHASH_Size, body_size);	

@ -4879,6 +4945,7 @@ void LLAgent::sendAgentSetAppearance()
 		// IMG_DEFAULT_AVATAR means not baked. 0 index should be ignored for baked textures
 		if (!gAgentAvatarp->isTextureDefined(texture_index, 0))
 		{
+			LL_DEBUGS("Avatar") << "texture not current for baked " << (S32)baked_index << " local " << (S32)texture_index << llendl;
 			textures_current = FALSE;
 			break;
 		}
@ -4891,6 +4958,12 @@ void LLAgent::sendAgentSetAppearance()
 	// composites to false, and update mesh textures.
 	if (textures_current)
 	{
+		bool enable_verbose_dumps = gSavedSettings.getBOOL("DebugAvatarAppearanceMessage");
+		std::string dump_prefix = gAgentAvatarp->getFullname() + "_sent_appearance";
+		if (enable_verbose_dumps)
+		{
+			dumpSentAppearance(dump_prefix);
+		}
 		LL_INFOS("Avatar") << gAgentAvatarp->avString() << "TAT: Sending cached texture data" << LL_ENDL;
 		for (U8 baked_index = 0; baked_index < BAKED_NUM_INDICES; baked_index++)
 		{
@ -4945,7 +5018,7 @@ void LLAgent::sendAgentSetAppearance()
 		}
 	}

-	llinfos << "Avatar XML num VisualParams transmitted = " << transmitted_params << llendl;
+	//llinfos << "Avatar XML num VisualParams transmitted = " << transmitted_params << llendl;
 	sendReliableMessage();
 }

--- a/indra/newview/llagent.h
+++ b/indra/newview/llagent.h
@ -895,6 +895,7 @@ private:
 public:
 	void			sendMessage(); // Send message to this agent's region
 	void			sendReliableMessage();
+	void 			dumpSentAppearance(const std::string& dump_prefix);
 	void			sendAgentSetAppearance();
 	void 			sendAgentDataUpdateRequest();
 	void 			sendAgentUserInfoRequest();
--- a/indra/newview/llagentwearables.cpp
+++ b/indra/newview/llagentwearables.cpp
@ -217,12 +217,13 @@ LLAgentWearables::sendAgentWearablesUpdateCallback::~sendAgentWearablesUpdateCal
 * @param todo Bitmask of actions to take on completion.
 */
 LLAgentWearables::addWearableToAgentInventoryCallback::addWearableToAgentInventoryCallback(
-	LLPointer<LLRefCount> cb, LLWearableType::EType type, U32 index, LLViewerWearable* wearable, U32 todo) :
+	LLPointer<LLRefCount> cb, LLWearableType::EType type, U32 index, LLViewerWearable* wearable, U32 todo, const std::string description) :
 	mType(type),
 	mIndex(index),	
 	mWearable(wearable),
 	mTodo(todo),
-	mCB(cb)
+	mCB(cb),
+	mDescription(description)
 {
 	llinfos << "constructor" << llendl;
 }
@ -262,7 +263,7 @@ void LLAgentWearables::addWearableToAgentInventoryCallback::fire(const LLUUID& i
 	}
 	if (mTodo & CALL_WEARITEM)
 	{
-		LLAppearanceMgr::instance().addCOFItemLink(inv_item, true);
+		LLAppearanceMgr::instance().addCOFItemLink(inv_item, true, NULL, mDescription);
 	}
 }

@ -462,6 +463,7 @@ void LLAgentWearables::saveWearable(const LLWearableType::EType type, const U32
 void LLAgentWearables::saveWearableAs(const LLWearableType::EType type,
 									  const U32 index,
 									  const std::string& new_name,
+									  const std::string& description,
 									  BOOL save_in_lost_and_found)
 {
 	if (!isWearableCopyable(type, index))
@ -493,7 +495,9 @@ void LLAgentWearables::saveWearableAs(const LLWearableType::EType type,
 			type,
 			index,
 			new_wearable,
-			addWearableToAgentInventoryCallback::CALL_WEARITEM);
+			addWearableToAgentInventoryCallback::CALL_WEARITEM,
+			description
+			);
 	LLUUID category_id;
 	if (save_in_lost_and_found)
 	{
@ -827,8 +831,7 @@ void LLAgentWearables::processAgentInitialWearablesUpdate(LLMessageSystem* mesgs

 	if (isAgentAvatarValid())
 	{
-		//gAgentAvatarp->clearPhases(); // reset phase timers for outfit loading.
-		gAgentAvatarp->getPhases().startPhase("process_initial_wearables_update");
+		gAgentAvatarp->startPhase("process_initial_wearables_update");
 		gAgentAvatarp->outputRezTiming("Received initial wearables update");
 	}

--- a/indra/newview/llagentwearables.h
+++ b/indra/newview/llagentwearables.h
@ -193,7 +193,7 @@ private:
 	// Save Wearables
 	//--------------------------------------------------------------------
 public:	
-	void			saveWearableAs(const LLWearableType::EType type, const U32 index, const std::string& new_name, BOOL save_in_lost_and_found);
+	void			saveWearableAs(const LLWearableType::EType type, const U32 index, const std::string& new_name, const std::string& description, BOOL save_in_lost_and_found);
 	void			saveWearable(const LLWearableType::EType type, const U32 index, BOOL send_update = TRUE,
 								 const std::string new_name = "");
 	void			saveAllWearables();
@ -293,7 +293,8 @@ private:
 											LLWearableType::EType type,
 											U32 index,
 											LLViewerWearable* wearable,
-											U32 todo = CALL_NONE);
+											U32 todo = CALL_NONE,
+											const std::string description = "");
 		virtual void fire(const LLUUID& inv_item);
 	private:
 		LLWearableType::EType mType;
@ -301,6 +302,7 @@ private:
 		LLViewerWearable* mWearable;
 		U32 mTodo;
 		LLPointer<LLRefCount> mCB;
+		std::string mDescription;
 	};

 }; // LLAgentWearables
--- a/indra/newview/llagentwearablesfetch.cpp
+++ b/indra/newview/llagentwearablesfetch.cpp
@ -85,7 +85,7 @@ LLInitialWearablesFetch::LLInitialWearablesFetch(const LLUUID& cof_id) :
 {
 	if (isAgentAvatarValid())
 	{
-		gAgentAvatarp->getPhases().startPhase("initial_wearables_fetch");
+		gAgentAvatarp->startPhase("initial_wearables_fetch");
 		gAgentAvatarp->outputRezTiming("Initial wearables fetch started");
 	}
 }
@ -111,7 +111,7 @@ void LLInitialWearablesFetch::done()
 // [/RLVa:KB]
 	if (isAgentAvatarValid())
 	{
-		gAgentAvatarp->getPhases().stopPhase("initial_wearables_fetch");
+		gAgentAvatarp->stopPhase("initial_wearables_fetch");
 		gAgentAvatarp->outputRezTiming("Initial wearables fetch done");
 	}
 }
--- a/indra/newview/llappearancemgr.cpp
+++ b/indra/newview/llappearancemgr.cpp
@ -49,6 +49,7 @@
 #include "llvoavatarself.h"
 #include "llviewerregion.h"
 #include "llwearablelist.h"
+#include "llsdutil.h"
 // [RLVa:KB] - Checked: 2011-05-22 (RLVa-1.3.1a)
 #include "rlvhandler.h"
 #include "rlvhelper.h"
@ -163,6 +164,16 @@ LLUUID findDescendentCategoryIDByName(const LLUUID& parent_id, const std::string
 	}
 }

+// We want this to be much lower (e.g. 15.0 is usually fine), bumping
+// up for now until we can diagnose some cases of very slow response
+// to requests.
+const F32 DEFAULT_RETRY_AFTER_INTERVAL = 300.0;
+
+// Given the current back-end problems, retrying is causing too many
+// duplicate items. Bump this back to 2 once they are resolved (or can
+// leave at 0 if the operations become actually reliable).
+const S32 DEFAULT_MAX_RETRIES = 0;
+
 class LLCallAfterInventoryBatchMgr: public LLEventTimer 
 {
 public:
@ -170,8 +181,8 @@ public:
 								 const std::string& phase_name,
 								 nullary_func_t on_completion_func,
 								 nullary_func_t on_failure_func = no_op,
-								 F32 retry_after = 15.0,
-								 S32 max_retries = 2
+								 F32 retry_after = DEFAULT_RETRY_AFTER_INTERVAL,
+								 S32 max_retries = DEFAULT_MAX_RETRIES
 		):
 		mDstCatID(dst_cat_id),
 		mTrackingPhase(phase_name),
@ -183,7 +194,7 @@ public:
 		mFailCount(0),
 		mCompletionOrFailureCalled(false),
 		mRetryCount(0),
-		LLEventTimer(retry_after)
+		LLEventTimer(5.0)
 	{
 		if (!mTrackingPhase.empty())
 		{
@ -206,52 +217,38 @@ public:
 	// Request or re-request operation for specified item.
 	void addItem(const LLUUID& item_id)
 	{
-		LLUUID linked_id;
-		if (gInventory.getItem(item_id))
+		LL_DEBUGS("Avatar") << "item_id " << item_id << llendl;
+
+		if (!requestOperation(item_id))
 		{
-			linked_id = gInventory.getItem(item_id)->getLinkedUUID();
-		}
-		else if (gInventory.getCategory(item_id))
-		{
-			linked_id = item_id;
-		}
-		else
-		{
-			llwarns << "no referent found for item_id " << item_id << llendl;
-			return;
-		}
-		LL_DEBUGS("Avatar") << "item_id " << item_id << " -> linked_id " << linked_id << llendl;
-		
-		if (ll_frand()<gSavedSettings.getF32("InventoryDebugSimulateOpFailureRate"))
-		{
-			// simulate server failure by not sending the request.
-			return;
-		}
-		
-		if (!requestOperation(linked_id))
-		{
-			LL_DEBUGS("Avatar") << "item_id " << item_id << " linked_id " << linked_id << " not requested" << llendl;
+			LL_DEBUGS("Avatar") << "item_id " << item_id << " requestOperation false, skipping" << llendl;
 			return;
 		}

 		mPendingRequests++;
 		// On a re-request, this will reset the timer.
-		mWaitTimes[linked_id] = LLTimer();
-		if (mRetryCounts.find(linked_id) == mRetryCounts.end())
+		mWaitTimes[item_id] = LLTimer();
+		if (mRetryCounts.find(item_id) == mRetryCounts.end())
 		{
-			mRetryCounts[linked_id] = 0;
+			mRetryCounts[item_id] = 0;
 		}
 		else
 		{
-			mRetryCounts[linked_id]++;
+			mRetryCounts[item_id]++;
 		}
-
 	}

 	virtual bool requestOperation(const LLUUID& item_id) = 0;

 	void onOp(const LLUUID& src_id, const LLUUID& dst_id, LLTimer timestamp)
 	{
+		if (ll_frand() < gSavedSettings.getF32("InventoryDebugSimulateLateOpRate"))
+		{
+			llwarns << "Simulating late operation by punting handling to later" << llendl;
+			doAfterInterval(boost::bind(&LLCallAfterInventoryBatchMgr::onOp,this,src_id,dst_id,timestamp),
+							mRetryAfter);
+			return;
+		}
 		mPendingRequests--;
 		F32 elapsed = timestamp.getElapsedTimeF32();
 		LL_DEBUGS("Avatar") << "op done, src_id " << src_id << " dst_id " << dst_id << " after " << elapsed << " seconds" << llendl;
@ -394,8 +391,8 @@ public:
 								const std::string& phase_name,
 								nullary_func_t on_completion_func,
 								nullary_func_t on_failure_func = no_op,
-								 F32 retry_after = 15.0,
-								 S32 max_retries = 2
+								 F32 retry_after = DEFAULT_RETRY_AFTER_INTERVAL,
+								 S32 max_retries = DEFAULT_MAX_RETRIES
 		):
 		LLCallAfterInventoryBatchMgr(dst_cat_id, phase_name, on_completion_func, on_failure_func, retry_after, max_retries)
 	{
@ -407,6 +404,11 @@ public:
 		LLViewerInventoryItem *item = gInventory.getItem(item_id);
 		llassert(item);
 		LL_DEBUGS("Avatar") << "copying item " << item_id << llendl;
+		if (ll_frand() < gSavedSettings.getF32("InventoryDebugSimulateOpFailureRate"))
+		{
+			LL_DEBUGS("Avatar") << "simulating failure by not sending request for item " << item_id << llendl;
+			return true;
+		}
 		copy_inventory_item(
 			gAgent.getID(),
 			item->getPermissions().getOwner(),
@ -427,8 +429,8 @@ public:
 								const std::string& phase_name,
 								nullary_func_t on_completion_func,
 								nullary_func_t on_failure_func = no_op,
-								 F32 retry_after = 15.0,
-								 S32 max_retries = 2
+								 F32 retry_after = DEFAULT_RETRY_AFTER_INTERVAL,
+								 S32 max_retries = DEFAULT_MAX_RETRIES
 		):
 		LLCallAfterInventoryBatchMgr(dst_cat_id, phase_name, on_completion_func, on_failure_func, retry_after, max_retries)
 	{
@ -441,17 +443,27 @@ public:
 		LLViewerInventoryItem *item = gInventory.getItem(item_id);
 		if (item)
 		{
+			if (item->getParentUUID() == mDstCatID)
+			{
+				LL_DEBUGS("Avatar") << "item " << item_id << " name " << item->getName() << " is already a child of " << mDstCatID << llendl;
+				return false;
+			}
 			LL_DEBUGS("Avatar") << "linking item " << item_id << " name " << item->getName() << " to " << mDstCatID << llendl;
 			// create an inventory item link.
+			if (ll_frand() < gSavedSettings.getF32("InventoryDebugSimulateOpFailureRate"))
+			{
+				LL_DEBUGS("Avatar") << "simulating failure by not sending request for item " << item_id << llendl;
+				return true;
+			}
 			link_inventory_item(gAgent.getID(),
-								item_id,
+								item->getLinkedUUID(),
 								mDstCatID,
 								item->getName(),
-								item->LLInventoryItem::getDescription(),
+								item->getActualDescription(),
 								LLAssetType::AT_LINK,
 								new LLBoostFuncInventoryCallback(
 									boost::bind(&LLCallAfterInventoryBatchMgr::onOp,this,item_id,_1,LLTimer())));
-			request_sent = true;
+			return true;
 		}
 		else
 		{
@ -459,7 +471,7 @@ public:
 			LLViewerInventoryCategory *catp = gInventory.getCategory(item_id);
 			if (!catp)
 			{
-				llwarns << "id not found as inventory item or category " << item_id << llendl;
+				llwarns << "link request failed, id not found as inventory item or category " << item_id << llendl;
 				return false;
 			}
 			const LLUUID cof = LLAppearanceMgr::instance().getCOF();
@ -469,6 +481,11 @@ public:

 			if (catp && catp->getPreferredType() == LLFolderType::FT_OUTFIT)
 			{
+				if (ll_frand() < gSavedSettings.getF32("InventoryDebugSimulateOpFailureRate"))
+				{
+					LL_DEBUGS("Avatar") << "simulating failure by not sending request for item " << item_id << llendl;
+					return true;
+				}
 				LL_DEBUGS("Avatar") << "linking folder " << item_id << " name " << catp->getName() << " to cof " << cof << llendl;
 				link_inventory_item(gAgent.getID(), item_id, cof, catp->getName(), "",
 									LLAssetType::AT_LINK_FOLDER, 
@ -1229,6 +1246,21 @@ S32 LLAppearanceMgr::getCOFVersion() const
 	}
 }

+S32 LLAppearanceMgr::getLastUpdateRequestCOFVersion() const
+{
+	return mLastUpdateRequestCOFVersion;
+}
+
+S32 LLAppearanceMgr::getLastAppearanceUpdateCOFVersion() const
+{
+	return mLastAppearanceUpdateCOFVersion;
+}
+
+void LLAppearanceMgr::setLastAppearanceUpdateCOFVersion(S32 new_val)
+{
+	mLastAppearanceUpdateCOFVersion = new_val;
+}
+
 const LLViewerInventoryItem* LLAppearanceMgr::getBaseOutfitLink()
 {
 	const LLUUID& current_outfit_cat = getCOF();
@ -1537,14 +1569,13 @@ void LLAppearanceMgr::shallowCopyCategoryContents(const LLUUID& src_id, const LL
 			{
 				if (item_name != FSLSLBridge::instance().currentFullName())
 				{
-					llinfos << "copying inventory link " << item_name << llendl;
-					//LLInventoryItem::getDescription() is used for a new description 
-					//to propagate ordering information saved in descriptions of links
+				//getActualDescription() is used for a new description 
+				//to propagate ordering information saved in descriptions of links
 					link_inventory_item(gAgent.getID(),
 										item->getLinkedUUID(),
 										dst_id,
 										item->getName(),
-										item->LLInventoryItem::getDescription(),
+										item->getActualDescription(),
 										LLAssetType::AT_LINK, cb);
 				}
 				break;
@ -1731,7 +1762,7 @@ void LLAppearanceMgr::purgeBaseOutfitLink(const LLUUID& category)
 	}
 }

-void LLAppearanceMgr::purgeCategory(const LLUUID& category, bool keep_outfit_links)
+void LLAppearanceMgr::purgeCategory(const LLUUID& category, bool keep_outfit_links, LLInventoryModel::item_array_t* keep_items)
 {
 	LLInventoryModel::cat_array_t cats;
 	LLInventoryModel::item_array_t items;
@ -1744,8 +1775,19 @@ void LLAppearanceMgr::purgeCategory(const LLUUID& category, bool keep_outfit_lin
 			continue;
 		if (item->getIsLinkType())
 		{
-			gInventory.purgeObject(item->getUUID());
+#if 0
+			if (keep_items && keep_items->find(item) != LLInventoryModel::item_array_t::FAIL)
+			{
+				llinfos << "preserved item" << llendl;
+			}
+			else
+			{
+				gInventory.purgeObject(item->getUUID());
+			}
+#else
+		gInventory.purgeObject(item->getUUID());
 		}
+#endif
 	}
 }

@ -1762,16 +1804,30 @@ void LLAppearanceMgr::purgeItems(const LLInventoryModel::item_array_t& items)
 	}
 }

-void LLAppearanceMgr::syncCOF(const LLInventoryModel::item_array_t& items, LLAssetType::EType type, 
+void LLAppearanceMgr::purgeItemsOfType(LLAssetType::EType asset_type)
+{
+	LLInventoryModel::cat_array_t cats;
+	LLInventoryModel::item_array_t items;
+	gInventory.collectDescendents(getCOF(), cats, items, LLInventoryModel::EXCLUDE_TRASH);
+	for (LLInventoryModel::item_array_t::const_iterator itItem = items.begin(); itItem != items.end(); ++itItem)
+	{
+		const LLInventoryItem* pItem = *itItem;
+		if ( (pItem->getIsLinkType()) && (asset_type == pItem->getType()) )
+		{
+			gInventory.purgeObject(pItem->getUUID());
+		}
+	}
+}
+
+void LLAppearanceMgr::syncCOF(const LLInventoryModel::item_array_t& items,
                              LLInventoryModel::item_array_t& items_to_add, LLInventoryModel::item_array_t& items_to_remove)
 {
 	const LLUUID idCOF = getCOF();
 	LLInventoryModel::item_array_t cur_cof_items, new_cof_items = items;

 	// Grab the current COF contents
-	LLIsType f(type);
 	LLInventoryModel::cat_array_t cats; 
-	gInventory.collectDescendentsIf(getCOF(), cats, cur_cof_items, LLInventoryModel::EXCLUDE_TRASH, f);
+	gInventory.collectDescendents(getCOF(), cats, cur_cof_items, LLInventoryModel::EXCLUDE_TRASH);

 	// Purge everything in cur_cof_items that isn't part of new_cof_items
 	for (S32 idxCurItem = 0, cntCurItem = cur_cof_items.count(); idxCurItem < cntCurItem; idxCurItem++)
@ -1781,7 +1837,8 @@ void LLAppearanceMgr::syncCOF(const LLInventoryModel::item_array_t& items, LLAss
 		{
 			// Item doesn't exist in new_cof_items => purge (if it's a link)
 			if ( (pItem->getIsLinkType()) && 
-			     (items_to_remove.end() != std::find(items_to_remove.begin(), items_to_remove.end(), pItem)) )
+				 (LLAssetType::AT_LINK_FOLDER != pItem->getActualType()) && 
+			     (items_to_remove.end() == std::find(items_to_remove.begin(), items_to_remove.end(), pItem)) )
 			{
 				items_to_remove.push_back(pItem);
 			}
@ -1845,7 +1902,7 @@ void LLAppearanceMgr::linkAll(const LLUUID& cat_uuid,
 							item->getLinkedUUID(),
 							cat_uuid,
 							item->getName(),
-							item->LLInventoryItem::getDescription(),
+							item->getActualDescription(),
 							LLAssetType::AT_LINK,
 							cb);

@ -1997,82 +2054,62 @@ void LLAppearanceMgr::updateCOF(LLInventoryModel::item_array_t& body_items_new,
 // [/RLVa:KB]
 	removeDuplicateItems(gest_items);
 	
-#ifndef LL_RELEASE_FOR_DOWNLOAD
-	LL_DEBUGS("Avatar") << self_av_string() << "Linking body items" << LL_ENDL;
-#endif
-
 	// Create links to new COF contents.
 	LL_DEBUGS("Avatar") << self_av_string() << "creating LLCallAfterInventoryLinkMgr" << LL_ENDL;
+
+	LLInventoryModel::item_array_t all_items;
+	all_items += body_items;
+	all_items += wear_items;
+	all_items += obj_items;
+	all_items += gest_items;
+
+// [SL:KB]
+	// Synchronize COF
+	//  -> it's possible that we don't link to any new items in which case 'link_waiter' fires when it goes out of scope below
+	LLInventoryModel::item_array_t items_add, items_remove;
+	syncCOF(all_items, items_add, items_remove);
+// [/SL:KB]
+
+	// Will link all the above items.
 	bool update_base_outfit_ordering = !append;
 	LLCallAfterInventoryLinkMgr *link_waiter =
-		new LLCallAfterInventoryLinkMgr(body_items,cof,"update_appearance_on_destroy",
+//		new LLCallAfterInventoryLinkMgr(all_items,cof,"update_appearance_on_destroy",
+// [SL:KB]
+		new LLCallAfterInventoryLinkMgr(items_add,cof,"update_appearance_on_destroy",
+// [/SL:KB]
 										boost::bind(&LLAppearanceMgr::updateAppearanceFromCOF,
 													LLAppearanceMgr::getInstance(),
 													update_base_outfit_ordering));

+	// Add link to outfit if category is an outfit. 
 // [SL:KB] - Checked: 2010-04-24 (RLVa-1.2.0f) | Added: RLVa-1.2.0f
-	if (!append)
+	if ( (!append) && (idOutfit.notNull()) )
 	{
-// [/SL:KB]
-#ifndef LL_RELEASE_FOR_DOWNLOAD
-		LL_DEBUGS("Avatar") << self_av_string() << "Linking wear items" << LL_ENDL;
-#endif
-		link_waiter->addItems(wear_items);
-
-#ifndef LL_RELEASE_FOR_DOWNLOAD
-		LL_DEBUGS("Avatar") << self_av_string() << "Linking obj items" << LL_ENDL;
-#endif
-		link_waiter->addItems(obj_items);
-
-#ifndef LL_RELEASE_FOR_DOWNLOAD
-		LL_DEBUGS("Avatar") << self_av_string() << "Linking gesture items" << LL_ENDL;
-#endif
-		link_waiter->addItems(gest_items);
-
-		// Add link to outfit if category is an outfit. 
-		if (idOutfit.notNull())
-		{
-			link_waiter->addItem(idOutfit);
-		}
-
-		// Remove current COF contents.  Have to do this after creating
-		// the link_waiter so links can be followed for any items that get
-		// carried over (e.g. keeping old shape if the new outfit does not
-		// contain one)
-		bool keep_outfit_links = append;
-		purgeCategory(cof, keep_outfit_links);
-		gInventory.notifyObservers();
-// [SL:KB] - Checked: 2010-04-24 (RLVa-1.2.0f) | Added: RLVa-1.2.0f
-	}
-	else
-	{
-		// Synchronize COF
-		//  -> it's possible that we don't link to any new items in which case 'link_waiter' fires when it goes out of scope below
-		LLInventoryModel::item_array_t items_add, items_remove;
-
-		syncCOF(body_items, LLAssetType::AT_BODYPART, items_add, items_remove);
-		syncCOF(wear_items, LLAssetType::AT_CLOTHING, items_add, items_remove);
-		syncCOF(obj_items, LLAssetType::AT_OBJECT, items_add, items_remove);
-		syncCOF(gest_items, LLAssetType::AT_GESTURE, items_add, items_remove);
-
-		link_waiter->addItems(items_add);
-		purgeItems(items_remove);
-		gInventory.notifyObservers();
+		link_waiter->addItem(idOutfit);
 	}
 // [/SL:KB]
-
-//	// Add link to outfit if category is an outfit. 
 //	if (!append)
 //	{
 //		link_waiter->addItem(category);
 //	}
 //
-//	// Remove current COF contents.  Have to do this after creating
-//	// the link_waiter so links can be followed for any items that get
-//	// carried over (e.g. keeping old shape if the new outfit does not
-//	// contain one)
+	// Remove current COF contents.  Have to do this after creating
+	// the link_waiter so links can be followed for any items that get
+	// carried over (e.g. keeping old shape if the new outfit does not
+	// contain one)
+// [SL:KB]
+	purgeItems(items_remove);
+
+	bool keep_outfit_links = append;
+	if (!keep_outfit_links)
+	{
+		purgeItemsOfType(LLAssetType::AT_LINK_FOLDER);
+	}
+
+	gInventory.notifyObservers();
+// [/SL:KB]
 //	bool keep_outfit_links = append;
-//	purgeCategory(cof, keep_outfit_links);
+//	purgeCategory(cof, keep_outfit_links, &all_items);
 //	gInventory.notifyObservers();

 	LL_DEBUGS("Avatar") << self_av_string() << "waiting for LLUpdateAppearanceOnDestroy" << LL_ENDL;
@ -2212,7 +2249,7 @@ static void remove_non_link_items(LLInventoryModel::item_array_t &items)
 }

 //a predicate for sorting inventory items by actual descriptions
-bool sort_by_description(const LLInventoryItem* item1, const LLInventoryItem* item2)
+bool sort_by_actual_description(const LLInventoryItem* item1, const LLInventoryItem* item2)
 {
 	if (!item1 || !item2) 
 	{
@ -2220,7 +2257,7 @@ bool sort_by_description(const LLInventoryItem* item1, const LLInventoryItem* it
 		return true;
 	}

-	return item1->LLInventoryItem::getDescription() < item2->LLInventoryItem::getDescription();
+	return item1->getActualDescription() < item2->getActualDescription();
 }

 void item_array_diff(LLInventoryModel::item_array_t& full_list,
@ -2302,9 +2339,8 @@ void LLAppearanceMgr::updateAppearanceFromCOF(bool update_base_outfit_ordering)
 		return;
 	}

-	LLVOAvatar::ScopedPhaseSetter(gAgentAvatarp,"update_appearance_from_cof");
-	
 	BoolSetter setIsInUpdateAppearanceFromCOF(mIsInUpdateAppearanceFromCOF);
+	selfStartPhase("update_appearance_from_cof");

 	LL_INFOS("Avatar") << self_av_string() << "starting" << LL_ENDL;

@ -2327,7 +2363,7 @@ void LLAppearanceMgr::updateAppearanceFromCOF(bool update_base_outfit_ordering)
 	}
 	// DRANO really should wait for the appearance message to set this.
 	// verify that deleting this line doesn't break anything.
-	gAgentAvatarp->setIsUsingServerBakes(gAgent.getRegion() && gAgent.getRegion()->getCentralBakeVersion());
+	//gAgentAvatarp->setIsUsingServerBakes(gAgent.getRegion() && gAgent.getRegion()->getCentralBakeVersion());
 	
 	//dumpCat(getCOF(),"COF, start");

@ -2752,10 +2788,11 @@ bool areMatchingWearables(const LLViewerInventoryItem *a, const LLViewerInventor
 class LLDeferredCOFLinkObserver: public LLInventoryObserver
 {
 public:
-	LLDeferredCOFLinkObserver(const LLUUID& item_id, bool do_update, LLPointer<LLInventoryCallback> cb = NULL):
+	LLDeferredCOFLinkObserver(const LLUUID& item_id, bool do_update, LLPointer<LLInventoryCallback> cb = NULL, std::string description = ""):
 		mItemID(item_id),
 		mDoUpdate(do_update),
-		mCallback(cb)
+		mCallback(cb),
+		mDescription(description)
 	{
 	}

@ -2777,23 +2814,24 @@ public:
 private:
 	const LLUUID mItemID;
 	bool mDoUpdate;
+	std::string mDescription;
 	LLPointer<LLInventoryCallback> mCallback;
 };


 // BAP - note that this runs asynchronously if the item is not already loaded from inventory.
 // Dangerous if caller assumes link will exist after calling the function.
-void LLAppearanceMgr::addCOFItemLink(const LLUUID &item_id, bool do_update, LLPointer<LLInventoryCallback> cb)
+void LLAppearanceMgr::addCOFItemLink(const LLUUID &item_id, bool do_update, LLPointer<LLInventoryCallback> cb, const std::string description)
 {
 	const LLInventoryItem *item = gInventory.getItem(item_id);
 	if (!item)
 	{
-		LLDeferredCOFLinkObserver *observer = new LLDeferredCOFLinkObserver(item_id, do_update, cb);
+		LLDeferredCOFLinkObserver *observer = new LLDeferredCOFLinkObserver(item_id, do_update, cb, description);
 		gInventory.addObserver(observer);
 	}
 	else
 	{
-		addCOFItemLink(item, do_update, cb);
+		addCOFItemLink(item, do_update, cb, description);
 	}
 }

@ -2816,8 +2854,9 @@ void modified_cof_cb(const LLUUID& inv_item)
 	}
 }

-void LLAppearanceMgr::addCOFItemLink(const LLInventoryItem *item, bool do_update, LLPointer<LLInventoryCallback> cb)
+void LLAppearanceMgr::addCOFItemLink(const LLInventoryItem *item, bool do_update, LLPointer<LLInventoryCallback> cb, const std::string description)
 {		
+	std::string link_description = description;
 	const LLViewerInventoryItem *vitem = dynamic_cast<const LLViewerInventoryItem*>(item);
 	if (!vitem)
 	{
@ -2888,18 +2927,48 @@ void LLAppearanceMgr::addCOFItemLink(const LLInventoryItem *item, bool do_update
 		{
 			cb = new LLBoostFuncInventoryCallback(modified_cof_cb);
 		}
-		const std::string description = vitem->getIsLinkType() ? vitem->getDescription() : "";
+		if (vitem->getIsLinkType())
+		{
+			link_description = vitem->getActualDescription();
+		}
 		link_inventory_item( gAgent.getID(),
 							 vitem->getLinkedUUID(),
 							 getCOF(),
 							 vitem->getName(),
-							 description,
+							 link_description,
 							 LLAssetType::AT_LINK,
 							 cb);
 	}
 	return;
 }

+LLInventoryModel::item_array_t LLAppearanceMgr::findCOFItemLinks(const LLUUID& item_id)
+{
+
+	LLInventoryModel::item_array_t result;
+	const LLViewerInventoryItem *vitem =
+		dynamic_cast<const LLViewerInventoryItem*>(gInventory.getItem(item_id));
+
+	if (vitem)
+	{
+		LLInventoryModel::cat_array_t cat_array;
+		LLInventoryModel::item_array_t item_array;
+		gInventory.collectDescendents(LLAppearanceMgr::getCOF(),
+									  cat_array,
+									  item_array,
+									  LLInventoryModel::EXCLUDE_TRASH);
+		for (S32 i=0; i<item_array.count(); i++)
+		{
+			const LLViewerInventoryItem* inv_item = item_array.get(i).get();
+			if (inv_item->getLinkedUUID() == vitem->getLinkedUUID())
+			{
+				result.put(item_array.get(i));
+			}
+		}
+	}
+	return result;
+}
+
 void LLAppearanceMgr::removeAllClothesFromAvatar()
 {
 	// Fetch worn clothes (i.e. the ones in COF).
@ -3090,7 +3159,7 @@ void LLAppearanceMgr::updateIsDirty()

 			if (item1->getLinkedUUID() != item2->getLinkedUUID() || 
 				item1->getName() != item2->getName() ||
-				item1->LLInventoryItem::getDescription() != item2->LLInventoryItem::getDescription())
+				item1->getActualDescription() != item2->getActualDescription())
 			{
 				mOutfitIsDirty = true;
 				return;
@ -3301,8 +3370,8 @@ struct WearablesOrderComparator
 			return true;
 		}
 		
-		const std::string& desc1 = item1->LLInventoryItem::getDescription();
-		const std::string& desc2 = item2->LLInventoryItem::getDescription();
+		const std::string& desc1 = item1->getActualDescription();
+		const std::string& desc2 = item2->getActualDescription();
 		
 		bool item1_valid = (desc1.size() == mControlSize) && (ORDER_NUMBER_SEPARATOR == desc1[0]);
 		bool item2_valid = (desc2.size() == mControlSize) && (ORDER_NUMBER_SEPARATOR == desc2[0]);
@ -3360,7 +3429,7 @@ void LLAppearanceMgr::updateClothingOrderingInfo(LLUUID cat_id, bool update_base
 			if (!item) continue;

 			std::string new_order_str = build_order_string((LLWearableType::EType)type, i);
-			if (new_order_str == item->LLInventoryItem::getDescription()) continue;
+			if (new_order_str == item->getActualDescription()) continue;

 			item->setDescription(new_order_str);
 			item->setComplete(TRUE);
@ -3444,13 +3513,27 @@ public:
 	// Successful completion.
 	/* virtual */ void result(const LLSD& content)
 	{
-		llinfos << "request OK" << llendl;
+		LL_DEBUGS("Avatar") << "content: " << ll_pretty_print_sd(content) << LL_ENDL;
+		if (content["success"].asBoolean())
+		{
+			LL_DEBUGS("Avatar") << "OK" << LL_ENDL;
+		}
+		else
+		{
+			onFailure(200);
+		}
 	}

 	// Error
-	/*virtual*/ void error(U32 status, const std::string& reason)
+	/*virtual*/ void errorWithContent(U32 status, const std::string& reason, const LLSD& content)
 	{
 		llwarns << "appearance update request failed, status: " << status << " reason: " << reason << llendl;
+		LL_DEBUGS("Avatar") << "content: " << ll_pretty_print_sd(content) << LL_ENDL;
+		onFailure(status);
+	}	
+
+	void onFailure(U32 status)
+	{
 		F32 seconds_to_wait;
 		if (mRetryPolicy->shouldRetry(status,seconds_to_wait))
 		{
@ -3464,13 +3547,19 @@ public:
 		{
 			llwarns << "giving up after too many retries" << llendl;
 		}
-	}	
+	}

 	LLPointer<LLHTTPRetryPolicy> mRetryPolicy;
 };

 void LLAppearanceMgr::requestServerAppearanceUpdate(LLCurl::ResponderPtr responder_ptr)
 {
+	if (gAgentAvatarp->isEditingAppearance()) 
+	{
+		// don't send out appearance updates if in appearance editing mode
+		return;
+	}
+
 	if (!gAgent.getRegion())
 	{
 		llwarns << "Region not set, cannot request server appearance update" << llendl;
@ -3641,8 +3730,8 @@ bool LLAppearanceMgr::moveWearable(LLViewerInventoryItem* item, bool closer_to_b
 	closer_to_body ? --it : ++it;
 	LLViewerInventoryItem* swap_item = *it;
 	if (!swap_item) return false;
-	std::string tmp = swap_item->LLInventoryItem::getDescription();
-	swap_item->setDescription(item->LLInventoryItem::getDescription());
+	std::string tmp = swap_item->getActualDescription();
+	swap_item->setDescription(item->getActualDescription());
 	item->setDescription(tmp);


@ -3675,7 +3764,7 @@ void LLAppearanceMgr::sortItemsByActualDescription(LLInventoryModel::item_array_
 {
 	if (items.size() < 2) return;

-	std::sort(items.begin(), items.end(), sort_by_description);
+	std::sort(items.begin(), items.end(), sort_by_actual_description);
 }

 //#define DUMP_CAT_VERBOSE
@ -3722,7 +3811,8 @@ LLAppearanceMgr::LLAppearanceMgr():
 	mOutfitIsDirty(false),
 	mOutfitLocked(false),
 	mIsInUpdateAppearanceFromCOF(false),
-	mLastUpdateRequestCOFVersion(LLViewerInventoryCategory::VERSION_UNKNOWN)
+	mLastUpdateRequestCOFVersion(LLViewerInventoryCategory::VERSION_UNKNOWN),
+	mLastAppearanceUpdateCOFVersion(LLViewerInventoryCategory::VERSION_UNKNOWN)
 {
 	LLOutfitObserver& outfit_observer = LLOutfitObserver::instance();

--- a/indra/newview/llappearancemgr.h
+++ b/indra/newview/llappearancemgr.h
@ -111,7 +111,14 @@ public:
 	const LLUUID getCOF() const;
 	S32 getCOFVersion() const;

+	// COF version of last viewer-initiated appearance update request.
 	S32 mLastUpdateRequestCOFVersion;
+	S32 getLastUpdateRequestCOFVersion() const;
+
+	// COF version of last appearance message received for self av.
+	S32 mLastAppearanceUpdateCOFVersion;
+	S32 getLastAppearanceUpdateCOFVersion() const;
+	void setLastAppearanceUpdateCOFVersion(S32 new_val);

 	// Finds the folder link to the currently worn outfit
 	const LLViewerInventoryItem *getBaseOutfitLink();
@ -146,9 +153,12 @@ public:
 				 LLPointer<LLInventoryCallback> cb);

 	// Add COF link to individual item.
-	void addCOFItemLink(const LLUUID& item_id, bool do_update = true, LLPointer<LLInventoryCallback> cb = NULL);
-	void addCOFItemLink(const LLInventoryItem *item, bool do_update = true, LLPointer<LLInventoryCallback> cb = NULL);
+	void addCOFItemLink(const LLUUID& item_id, bool do_update = true, LLPointer<LLInventoryCallback> cb = NULL, const std::string description = "");
+	void addCOFItemLink(const LLInventoryItem *item, bool do_update = true, LLPointer<LLInventoryCallback> cb = NULL, const std::string description = "");

+	// Find COF entries referencing the given item.
+	LLInventoryModel::item_array_t findCOFItemLinks(const LLUUID& item_id);
+	
 	// Remove COF entries
 	void removeCOFItemLinks(const LLUUID& item_id);
 	void removeCOFLinksOfType(LLWearableType::EType type);
@ -223,15 +233,15 @@ private:
 								   LLInventoryModel::item_array_t& gest_items,
 								   bool follow_folder_links);

-	void purgeCategory(const LLUUID& category, bool keep_outfit_links);
-
+	void purgeCategory(const LLUUID& category, bool keep_outfit_links, LLInventoryModel::item_array_t* keep_items = NULL);
 	static void onOutfitRename(const LLSD& notification, const LLSD& response);

 	void setOutfitLocked(bool locked);

 // [SL:KB] - Checked: 2010-04-24 (RLVa-1.2.0f) | Added: RLVa-1.2.0f
 	void purgeItems(const LLInventoryModel::item_array_t& items);
-	void syncCOF(const LLInventoryModel::item_array_t& items, LLAssetType::EType type, 
+	void purgeItemsOfType(LLAssetType::EType asset_type);
+	void syncCOF(const LLInventoryModel::item_array_t& items, 
 	             LLInventoryModel::item_array_t& items_to_add, LLInventoryModel::item_array_t& items_to_remove);
 // [/SL:KB]

--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@ -93,6 +93,10 @@
 // [SL:KB] - Patch: Appearance-Misc | Checked: 2013-02-12 (Catznip-3.4)
 #include "llappearancemgr.h"
 // [/SL:KB]
+// [RLVa:KB] - Checked: 2010-05-03 (RLVa-1.2.0g)
+#include "rlvhandler.h"
+// [/RLVa:KB]
+
 #include "llweb.h"
 #include "llsecondlifeurls.h"
 #include "llupdaterservice.h"
@ -480,14 +484,13 @@ void idle_afk_check()
 {
 	// check idle timers
 	F32 current_idle = gAwayTriggerTimer.getElapsedTimeF32();
-	static LLCachedControl<S32> afkTimeout(gSavedSettings, "AFKTimeout");
 //	F32 afk_timeout  = gSavedSettings.getS32("AFKTimeout");
 // [RLVa:KB] - Checked: 2010-05-03 (RLVa-1.2.0g) | Modified: RLVa-1.2.0g
 #ifdef RLV_EXTENSION_CMD_ALLOWIDLE
 	// Enforce an idle time of 30 minutes if @allowidle=n restricted
-	F32 afk_timeout = (!gRlvHandler.hasBehaviour(RLV_BHVR_ALLOWIDLE)) ? (F32)afkTimeout : 60 * 30;
+	F32 afk_timeout = (!gRlvHandler.hasBehaviour(RLV_BHVR_ALLOWIDLE)) ? gSavedSettings.getS32("AFKTimeout") : 60 * 30;
 #else
-	F32 afk_timeout = (F32)afkTimeout;
+	F32 afk_timeout = gSavedSettings.getS32("AFKTimeout");
 #endif // RLV_EXTENSION_CMD_ALLOWIDLE
 // [/RLVa:KB]
 	if (afk_timeout && (current_idle > afk_timeout) && ! gAgent.getAFK())
@ -2397,18 +2400,12 @@ void errorCallback(const std::string &error_string)
 	gLLErrorActivated = true;
 	
 //	LLError::crashAndLoop(error_string);
-// [SL:KB] - Patch: Viewer-Build | Checked: 2010-12-04 (Catznip-2.6.0a) | Added: Catznip-2.4.0g
-#if !LL_RELEASE_FOR_DOWNLOAD
-#if LL_WINDOWS
+// [SL:KB] - Patch: Viewer-Build | Checked: 2010-12-04 (Catznip-2.4)
+#if !LL_RELEASE_FOR_DOWNLOAD && LL_WINDOWS
 	DebugBreak();
-#elif LL_LINUX
-	raise(SIGINT);
-#else // other OSes could hook in here, too
-	LLError::crashAndLoop(error_string);
-#endif // LL_WINDOWS
 #else
 	LLError::crashAndLoop(error_string);
-#endif // !LL_RELEASE_FOR_DOWNLOAD
+#endif // LL_RELEASE_WITH_DEBUG_INFO && LL_WINDOWS
 // [/SL:KB]
 }

@ -4021,6 +4018,12 @@ void LLAppViewer::requestQuit()

 	// Try to send metrics back to the grid
 	metricsSend(!gDisconnected);
+
+	// Try to send last batch of avatar rez metrics.
+	if (!gDisconnected && isAgentAvatarValid())
+	{
+		gAgentAvatarp->updateAvatarRezMetrics(true); // force a last packet to be sent.
+	}
 	
 	LLHUDEffectSpiral *effectp = (LLHUDEffectSpiral*)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_POINT, TRUE);
 	effectp->setPositionGlobal(gAgent.getPositionGlobal());
@ -4863,7 +4866,6 @@ void LLAppViewer::idle()
 			// The 5-second interval is nice for this purpose.  If the object debug
 			// bit moves or is disabled, please give this a suitable home.
 			LLViewerAssetStatsFF::record_fps_main(gFPSClamped);
-			LLViewerAssetStatsFF::record_avatar_stats();
 		}
 	}

@ -5461,6 +5463,11 @@ void LLAppViewer::disconnectViewer()
 	// close inventory interface, close all windows
 	LLFloaterInventory::cleanup();

+// [SL:KB] - Patch: Appearance-Misc | Checked: 2013-02-12 (Catznip-3.4)
+	// Destroying all objects below will trigger attachment detaching code and attempt to remove the COF links for them
+	LLAppearanceMgr::instance().setAttachmentInvLinkEnable(false);
+// [/SL:KB]
+
 // [SL:KB] - Patch: Appearance-Misc | Checked: 2013-02-12 (Catznip-3.4)
 	// Destroying all objects below will trigger attachment detaching code and attempt to remove the COF links for them
 	LLAppearanceMgr::instance().setAttachmentInvLinkEnable(false);
--- a/indra/newview/llavatariconctrl.cpp
+++ b/indra/newview/llavatariconctrl.cpp
--- a/indra/newview/llavatarlistitem.cpp
+++ b/indra/newview/llavatarlistitem.cpp
@ -220,13 +220,11 @@ S32 LLAvatarListItem::notifyParent(const LLSD& info)
 void LLAvatarListItem::onMouseEnter(S32 x, S32 y, MASK mask)
 {
 	getChildView("hovered_icon")->setVisible( true);
-
-	// AO, removed on-hover visibility. Don't do this. instead flip info buttons on full-time in postbuild.
 //	mInfoBtn->setVisible(mShowInfoBtn);
 //	mProfileBtn->setVisible(mShowProfileBtn);
 // [RLVa:KB] - Checked: 2010-04-05 (RLVa-1.2.2a) | Added: RLVa-1.2.0d
-//	mInfoBtn->setVisible( (mShowInfoBtn) && ((!mRlvCheckShowNames) || (!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES))) );
-//	mProfileBtn->setVisible( (mShowProfileBtn) && ((!mRlvCheckShowNames) || (!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES))) );
+	mInfoBtn->setVisible( (mShowInfoBtn) && ((!mRlvCheckShowNames) || (!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES))) );
+	mProfileBtn->setVisible( (mShowProfileBtn) && ((!mRlvCheckShowNames) || (!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES))) );
 // [/RLVa:KB]

 	mHovered = true;
@ -699,15 +697,7 @@ void LLAvatarListItem::onAvatarNameCache(const LLAvatarName& av_name)
 //	setAvatarToolTip(av_name.mUsername);
 // [RLVa:KB] - Checked: 2010-10-31 (RLVa-1.2.2a) | Modified: RLVa-1.2.2a
 	bool fRlvFilter = (mRlvCheckShowNames) && (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES));
-	if (mShowDisplayName && !mShowUsername)
-		setAvatarName( (!fRlvFilter) ? av_name.mDisplayName : RlvStrings::getAnonym(av_name) );
-	else if (!mShowDisplayName && mShowUsername)
-		setAvatarName( (!fRlvFilter) ? av_name.mUsername : RlvStrings::getAnonym(av_name) );
-	else 
-		setAvatarName( (!fRlvFilter) ? av_name.getCompleteName() : RlvStrings::getAnonym(av_name) );
-
-	// NOTE: If you change this, you will break sorting the contacts list
-	//  by username unless you go change the comparator too. -- TS	
+	setAvatarName( (!fRlvFilter) ? av_name.mDisplayName : RlvStrings::getAnonym(av_name) );
 	setAvatarToolTip( (!fRlvFilter) ? av_name.mUsername : RlvStrings::getAnonym(av_name) );
 	// TODO-RLVa: bit of a hack putting this here. Maybe find a better way?
 	mAvatarIcon->setDrawTooltip(!fRlvFilter);
@ -715,7 +705,7 @@ void LLAvatarListItem::onAvatarNameCache(const LLAvatarName& av_name)

 	//KC - store the username for use in sorting
 	mUserName = av_name.mUsername;
-
+	
 	//requesting the list to resort
 	notifyParent(LLSD().with("sort", LLSD()));
 	
--- a/indra/newview/llchathistory.cpp
+++ b/indra/newview/llchathistory.cpp
@ -335,24 +335,12 @@ public:
 			{
 				user_name->setValue( LLSD() );
 				LLAvatarNameCache::get(mAvatarID,
-					boost::bind(&LLChatHistoryHeader::onAvatarNameCache, this, _1, _2, chat.mChatType, chat.mFromNameGroup)); // FS:LO FIRE-5230 - Chat Console Improvement: Replacing the "IM" in front of group chat messages with the actual group name
-					//boost::bind(&LLChatHistoryHeader::onAvatarNameCache, this, _1, _2, chat.mChatType));
+					boost::bind(&LLChatHistoryHeader::onAvatarNameCache, this, _1, _2));
 			}
 			else
 			{
 				// If the agent's chat was subject to @shownames=n we should display their anonimized name
 				mFrom = chat.mFromName;
-				// FS:LO FIRE-5230 - Chat Console Improvement: Replacing the "IM" in front of group chat messages with the actual group name
-				//if (chat.mChatType == CHAT_TYPE_IM) mFrom = LLTrans::getString("IMPrefix") + " " + mFrom;
-				if (chat.mChatType == CHAT_TYPE_IM)
-				{
-					mFrom = LLTrans::getString("IMPrefix") + " " + mFrom;
-				}
-				else if (chat.mChatType == CHAT_TYPE_IM_GROUP)
-				{
-					mFrom = LLTrans::getString("IMPrefix") + " " + chat.mFromNameGroup + mFrom;
-				}
-				// FS:LO FIRE-5230 - Chat Console Improvement: Replacing the "IM" in front of group chat messages with the actual group name
 				user_name->setValue(mFrom);
 				user_name->setToolTip(mFrom);
 				setToolTip(mFrom);
--- a/indra/newview/llcompilequeue.cpp
+++ b/indra/newview/llcompilequeue.cpp
@ -165,18 +165,6 @@ BOOL LLFloaterScriptQueue::start()
 	//llinfos << "LLFloaterCompileQueue::start()" << llendl;
 	std::string buffer;

-	LLSelectMgr *mgr = LLSelectMgr::getInstance();
-	LLObjectSelectionHandle selectHandle = mgr->getSelection();
-	U32 n_objects = 0;
-	if (gSavedSettings.getBOOL("EditLinkedParts"))
-	{
-		n_objects = selectHandle->getObjectCount();
-	}
-	else
-	{
-		n_objects = selectHandle->getRootObjectCount();
-	}
-
 	LLStringUtil::format_map_t args;
 	args["[START]"] = mStartString;
 	args["[COUNT]"] = llformat ("%d", mObjectIDs.count());
--- a/indra/newview/llfloaterinspect.cpp
+++ b/indra/newview/llfloaterinspect.cpp
@ -45,8 +45,6 @@
 #include "rlvhandler.h"
 #include "llagent.h"
 // [/RLVa:KB]
-#include "llavatarname.h"
-#include "lltrans.h"

 //LLFloaterInspect* LLFloaterInspect::sInstance = NULL;

@ -242,16 +240,18 @@ void LLFloaterInspect::refresh()
 		const LLUUID& idOwner = obj->mPermissions->getOwner();
 		const LLUUID& idCreator = obj->mPermissions->getCreator();
 		LLAvatarName av_name;
-// [RLVa:KB] - Checked: 2010-11-01 (RLVa-1.2.2a) | Modified: RLVa-1.2.2a

-		// work with the name if we actually get a result
+		// Only work with the names if we actually get a result
 		// from the name cache. If not, defer setting the
 		// actual name and set a placeholder.
 		if (LLAvatarNameCache::get(idOwner, &av_name))
 		{
-			bool fRlvFilterOwner = (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) && (!av_name.mIsTemporaryName) && (idOwner != gAgent.getID()) && 
+//			owner_name = av_name.getCompleteName();
+// [RLVa:KB] - Checked: 2010-11-01 (RLVa-1.2.2a) | Modified: RLVa-1.2.2a
+			bool fRlvFilterOwner = (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) && (idOwner != gAgent.getID()) && 
 				(!obj->mPermissions->isGroupOwned());
 			owner_name = (!fRlvFilterOwner) ? av_name.getCompleteName() : RlvStrings::getAnonym(av_name);
+// [/RLVa:KB]
 		}
 		else
 		{
@ -261,16 +261,20 @@ void LLFloaterInspect::refresh()

 		if (LLAvatarNameCache::get(idCreator, &av_name))
 		{
-			bool fRlvFilterCreator = (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) && (!av_name.mIsTemporaryName) && (idCreator != gAgent.getID()) && 
+//			creator_name = av_name.getCompleteName();
+// [RLVa:KB] - Checked: 2010-11-01 (RLVa-1.2.2a) | Modified: RLVa-1.2.2a
+			const LLUUID& idCreator = obj->mPermissions->getCreator();
+			LLAvatarNameCache::get(idCreator, &av_name);
+			bool fRlvFilterCreator = (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) && (idCreator != gAgent.getID()) && 
 				( (obj->mPermissions->getOwner() == idCreator) || (RlvUtil::isNearbyAgent(idCreator)) );
 			creator_name = (!fRlvFilterCreator) ? av_name.getCompleteName() : RlvStrings::getAnonym(av_name);
+// [/RLVa:KB]
 		}
 		else
 		{
 			creator_name = LLTrans::getString("RetrievingData");
 			LLAvatarNameCache::get(idCreator, boost::bind(&LLFloaterInspect::onGetAvNameCallback, _1, _2, this));
 		}
-// [/RLVa:KB]

 		row["id"] = obj->getObject()->getID();
 		row["columns"][0]["column"] = "object_name";
--- a/indra/newview/llfloaterpreference.cpp
+++ b/indra/newview/llfloaterpreference.cpp
@ -1437,6 +1437,11 @@ void LLFloaterPreference::refreshEnabledState()
 	// <FS:Ansariel> Radio group "ReflectionDetailRadio" doesn't exist as of 20/11/2012
 	//LLRadioGroup* radio_reflection_detail = getChild<LLRadioGroup>("ReflectionDetailRadio");
 	
+// [RLVa:KB] - Checked: 2010-04-09 (RLVa-1.2.0e) | Modified: RLVa-1.2.0e
+	if (rlv_handler_t::isEnabled())
+		childSetEnabled("busy_response", !gRlvHandler.hasBehaviour(RLV_BHVR_SENDIM));
+// [/RLVa:KB]
+
 // [RLVa:KB] - Checked: 2010-04-09 (RLVa-1.2.0e) | Modified: RLVa-1.2.0e
 	if (rlv_handler_t::isEnabled())
 		childSetEnabled("busy_response", !gRlvHandler.hasBehaviour(RLV_BHVR_SENDIM));
--- a/indra/newview/llfloatersettingsdebug.cpp
+++ b/indra/newview/llfloatersettingsdebug.cpp
@ -337,6 +337,7 @@ void LLFloaterSettingsDebug::updateControl()
 	{
 // [RLVa:KB] - Checked: 2011-05-28 (RLVa-1.4.0a) | Modified: RLVa-1.4.0a
 		// If "HideFromEditor" was toggled while the floater is open then we need to manually disable access to the control
+		// NOTE: this runs per-frame so there's no need to explictly handle onCommitSettings() or onClickDefault()
 		mOldVisibility=mCurrentControlVariable->isHiddenFromSettingsEditor();
 		mSpinner1->setEnabled(!mOldVisibility);
 		mSpinner2->setEnabled(!mOldVisibility);
@ -348,6 +349,7 @@ void LLFloaterSettingsDebug::updateControl()
 		mDefaultButton->setEnabled(!mOldVisibility);
 // [/RLVa:KB]

+
 		mCopyButton->setEnabled(TRUE);
 		mSanityButton->setVisible(!mCurrentControlVariable->isSane());

--- a/indra/newview/llfloatersidepanelcontainer.cpp
+++ b/indra/newview/llfloatersidepanelcontainer.cpp
@ -28,6 +28,7 @@

 #include "llfloaterreg.h"
 #include "llfloatersidepanelcontainer.h"
+#include "llpaneleditwearable.h"

 // newview includes
 #include "llsidetraypanelcontainer.h"
@ -76,7 +77,16 @@ void LLFloaterSidePanelContainer::onClickCloseBtn()
 			panel_appearance->showOutfitsInventoryPanel();
 		}
 	}
-
+	
+	if ( panel_outfit_edit )
+	{
+		LLSidepanelAppearance* panel_appearance = dynamic_cast<LLSidepanelAppearance*>(getPanel("appearance"));
+		if ( panel_appearance )
+		{
+			panel_appearance->getWearable()->onClose();
+			panel_appearance->showOutfitsInventoryPanel();
+		}
+	}
 	LLFloater::onClickCloseBtn();
 }

--- a/indra/newview/llglsandbox.cpp
+++ b/indra/newview/llglsandbox.cpp
@ -258,6 +258,13 @@ void LLToolSelectRect::handleRectangleSelection(S32 x, S32 y, MASK mask)
 				continue;
 			}

+// [RLVa:KB] - Checked: 2010-11-29 (RLVa-1.3.0c) | Added: RLVa-1.3.0c
+			if ( (rlv_handler_t::isEnabled()) && (!gRlvHandler.canEdit(vobjp)) )
+			{
+				continue;
+			}
+// [/RLVa:KB]
+
 // [RLVa:KB] - Checked: 2010-11-29 (RLVa-1.3.0c) | Added: RLVa-1.3.0c
 			if ( (rlv_handler_t::isEnabled()) && (!gRlvHandler.canEdit(vobjp)) )
 			{
--- a/indra/newview/llgroupactions.cpp
+++ b/indra/newview/llgroupactions.cpp
@ -41,6 +41,10 @@
 #include "llstatusbar.h"	// can_afford_transaction()
 #include "llimfloater.h"
 #include "groupchatlistener.h"
+// [RLVa:KB] - Checked: 2011-03-28 (RLVa-1.3.0f)
+#include "llslurl.h"
+#include "rlvhandler.h"
+// [/RLVa:KB]

 // [RLVa:KB] - Checked: 2011-03-28 (RLVa-1.3.0f)
 #include "llslurl.h"
--- a/indra/newview/llimfloater.cpp
+++ b/indra/newview/llimfloater.cpp
@ -303,6 +303,56 @@ void LLIMFloater::sendMsg()
 			//utf8_text = utf8str_truncate(utf8_text, MAX_MSG_BUF_SIZE - 1);
 			//</FS:TS> FIRE-787
 			
+// [RLVa:KB] - Checked: 2010-11-30 (RLVa-1.3.0c) | Modified: RLVa-1.3.0c
+			if ( (gRlvHandler.hasBehaviour(RLV_BHVR_SENDIM)) || (gRlvHandler.hasBehaviour(RLV_BHVR_SENDIMTO)) )
+			{
+				LLIMModel::LLIMSession* pIMSession = LLIMModel::instance().findIMSession(mSessionID);
+				RLV_ASSERT(pIMSession);
+
+				bool fRlvFilter = !pIMSession;
+				if (pIMSession)
+				{
+					switch (pIMSession->mSessionType)
+					{
+						case LLIMModel::LLIMSession::P2P_SESSION:	// One-on-one IM
+							fRlvFilter = !gRlvHandler.canSendIM(mOtherParticipantUUID);
+							break;
+						case LLIMModel::LLIMSession::GROUP_SESSION:	// Group chat
+							fRlvFilter = !gRlvHandler.canSendIM(mSessionID);
+							break;
+						case LLIMModel::LLIMSession::ADHOC_SESSION:	// Conference chat: allow if all participants can be sent an IM
+							{
+								if (!pIMSession->mSpeakers)
+								{
+									fRlvFilter = true;
+									break;
+								}
+
+								LLSpeakerMgr::speaker_list_t speakers;
+								pIMSession->mSpeakers->getSpeakerList(&speakers, TRUE);
+								for (LLSpeakerMgr::speaker_list_t::const_iterator itSpeaker = speakers.begin(); 
+										itSpeaker != speakers.end(); ++itSpeaker)
+								{
+									const LLSpeaker* pSpeaker = *itSpeaker;
+									if ( (gAgent.getID() != pSpeaker->mID) && (!gRlvHandler.canSendIM(pSpeaker->mID)) )
+									{
+										fRlvFilter = true;
+										break;
+									}
+								}
+							}
+							break;
+						default:
+							fRlvFilter = true;
+							break;
+					}
+				}
+
+				if (fRlvFilter)
+					utf8_text = RlvStrings::getString(RLV_STRING_BLOCKED_SENDIM);
+			}
+// [/RLVa:KB]
+
 // [RLVa:KB] - Checked: 2010-11-30 (RLVa-1.3.0c) | Modified: RLVa-1.3.0c
 			if ( (gRlvHandler.hasBehaviour(RLV_BHVR_SENDIM)) || (gRlvHandler.hasBehaviour(RLV_BHVR_SENDIMTO)) )
 			{
--- a/indra/newview/llinventorybridge.cpp
+++ b/indra/newview/llinventorybridge.cpp
@ -5423,12 +5423,6 @@ void LLObjectBridge::performAction(LLInventoryModel* model, std::string action)
 	{
 		LLAppearanceMgr::instance().wearItemOnAvatar(mUUID, true, false); // Don't replace if adding.
 	}
-// [SL:KB] - Patch: Inventory-AttachmentEdit - Checked: 2010-08-25 (Catznip-2.2.0a) | Added: Catznip-2.1.2a
-	else if ("edit" == action)
-	{
-		handle_attachment_edit(mUUID);
-	}
-// [/SL:KB]
 	else if (isRemoveAction(action))
 	{
 		LLAppearanceMgr::instance().removeItemFromAvatar(mUUID);
--- a/indra/newview/llinventoryfunctions.cpp
+++ b/indra/newview/llinventoryfunctions.cpp
@ -455,6 +455,13 @@ BOOL get_is_category_renameable(const LLInventoryModel* model, const LLUUID& id)
 		return FALSE;
 	}

+// [RLVa:KB] - Checked: 2011-03-29 (RLVa-1.3.0g) | Modified: RLVa-1.3.0g
+	if ( (rlv_handler_t::isEnabled()) && (model == &gInventory) && (!RlvFolderLocks::instance().canRenameFolder(id)) )
+	{
+		return FALSE;
+	}
+// [/RLVa:KB]
+
 // [RLVa:KB] - Checked: 2011-03-29 (RLVa-1.3.0g) | Modified: RLVa-1.3.0g
 	if ( (rlv_handler_t::isEnabled()) && (model == &gInventory) && (!RlvFolderLocks::instance().canRenameFolder(id)) )
 	{
--- a/indra/newview/llinventorylistitem.cpp
+++ b/indra/newview/llinventorylistitem.cpp
@ -231,7 +231,7 @@ const std::string& LLPanelInventoryListItemBase::getDescription() const
 	{
 		return LLStringUtil::null;
 	}
-	return inv_item->getDescription();
+	return inv_item->getActualDescription();
 }

 time_t LLPanelInventoryListItemBase::getCreationDate() const
--- a/indra/newview/llmeshrepository.cpp
+++ b/indra/newview/llmeshrepository.cpp
--- a/indra/newview/llnearbychathandler.cpp
+++ b/indra/newview/llnearbychathandler.cpp
@ -552,6 +552,7 @@ void LLNearbyChatHandler::processChat(const LLChat& chat_msg,
 	if (rlv_handler_t::isEnabled())
 	{
 		// NOTE-RLVa: we can only filter the *message* here since most everything else will already be part of "args" as well
+		LLChat& tmp_chat = const_cast<LLChat&>(chat_msg);
 		if ( (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC)) && (!tmp_chat.mRlvLocFiltered) && (CHAT_SOURCE_AGENT != tmp_chat.mSourceType) )
 		{
 			RlvUtil::filterLocation(tmp_chat.mText);
@ -565,10 +566,10 @@ void LLNearbyChatHandler::processChat(const LLChat& chat_msg,
 	}
 // [/RLVa:KB]

+
 // ## Zi - Post merge fixup ## //	LLFloater* chat_bar = LLFloaterReg::getInstance("chat_bar");
 // ## Zi - Post merge fixup ## //	LLNearbyChat* nearby_chat = chat_bar->findChild<LLNearbyChat>("nearby_chat");
 	LLFloaterNearbyChat* nearby_chat = LLFloaterReg::getTypedInstance<LLFloaterNearbyChat>("nearby_chat", LLSD());	// ## Zi - Post merge fixup ##
-
 	// Build notification data 
 	LLSD notification;
 	notification["message"] = chat_msg.mText;
@ -777,8 +778,8 @@ void LLNearbyChatHandler::processChat(const LLChat& chat_msg,
 			//LLSD notification;
 			notification["id"] = id;
 // [RLVa:KB] - Checked: 2010-04-20 (RLVa-1.2.0f) | Added: RLVa-1.2.0f
-			if (rlv_handler_t::isEnabled())
-				notification["show_icon_tooltip"] = !chat_msg.mRlvNamesFiltered;
+		if (rlv_handler_t::isEnabled())
+			notification["show_icon_tooltip"] = !chat_msg.mRlvNamesFiltered;
 // [/RLVa:KB]
 			notification["message"] = chat_msg.mText;
 			//notification["from"] = chat_msg.mFromName;
--- a/indra/newview/llnetmap.cpp
+++ b/indra/newview/llnetmap.cpp
@ -408,7 +408,11 @@ void LLNetMap::draw()
 			pos_map = globalPosToView(positions[i]);
 			LLUUID uuid = avatar_ids[i];

-			bool show_as_friend = (LLAvatarTracker::instance().getBuddyInfo(uuid) != NULL);
+// [RLVa:KB] - Checked: 2010-04-19 (RLVa-1.2.0f) | Modified: RLVa-1.2.0f
+			bool show_as_friend = (LLAvatarTracker::instance().getBuddyInfo(uuid) != NULL) &&
+				(!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES));
+// [/RLVa:KB]
+//			bool show_as_friend = (LLAvatarTracker::instance().getBuddyInfo(uuid) != NULL);

 			LLColor4 color = show_as_friend ? map_avatar_friend_color : map_avatar_color;

--- a/indra/newview/llpaneleditwearable.cpp
+++ b/indra/newview/llpaneleditwearable.cpp
@ -856,6 +856,14 @@ void LLPanelEditWearable::draw()
        LLPanel::draw();
 }

+void LLPanelEditWearable::onClose()
+{
+	if ( isDirty() )
+	{
+		revertChanges();
+	}
+}
+
 void LLPanelEditWearable::setVisible(BOOL visible)
 {
        if (!visible)
@ -874,9 +882,12 @@ void LLPanelEditWearable::setWearable(LLViewerWearable *wearable, BOOL disable_c

 //static 
 void LLPanelEditWearable::onBackButtonClicked(void* userdata)
-{
-    LLPanelEditWearable *panel = (LLPanelEditWearable*) userdata;
-	panel->saveChanges(true);
+{	
+	LLPanelEditWearable *panel = (LLPanelEditWearable*) userdata;    
+	if ( panel->isDirty() )
+	{
+		LLAppearanceMgr::instance().setOutfitDirty( true );		
+	}
 }

 //static 
@ -1045,16 +1056,47 @@ void LLPanelEditWearable::saveChanges(bool force_save_as)
        U32 index = gAgentWearables.getWearableIndex(mWearablePtr);

        std::string new_name = mNameEditor->getText();
+
+		// Find an existing link to this wearable's inventory item, if any, and its description field.
+		LLInventoryItem *link_item = NULL;
+		std::string description;
+		LLInventoryModel::item_array_t links =
+			LLAppearanceMgr::instance().findCOFItemLinks(mWearablePtr->getItemID());
+		if (links.size()>0)
+		{
+			link_item = links.get(0).get();
+			if (link_item && link_item->getIsLinkType())
+			{
+				description = link_item->getActualDescription();
+			}
+		}
+
        if (force_save_as)
        {
-                // the name of the wearable has changed, re-save wearable with new name
-                LLAppearanceMgr::instance().removeCOFItemLinks(mWearablePtr->getItemID());
-                gAgentWearables.saveWearableAs(mWearablePtr->getType(), index, new_name, FALSE);
-                mNameEditor->setText(mWearableItem->getName());
+			// the name of the wearable has changed, re-save wearable with new name
+			LLAppearanceMgr::instance().removeCOFItemLinks(mWearablePtr->getItemID());
+			gAgentWearables.saveWearableAs(mWearablePtr->getType(), index, new_name, description, FALSE);
+			mNameEditor->setText(mWearableItem->getName());
        }
        else
        {
-                gAgentWearables.saveWearable(mWearablePtr->getType(), index, TRUE, new_name);
+			// Make another copy of this link, with the same
+			// description.  This is needed to bump the COF
+			// version so texture baking service knows appearance has changed.
+			if (link_item)
+			{
+				// Create new link
+				link_inventory_item( gAgent.getID(),
+									 link_item->getLinkedUUID(),
+									 LLAppearanceMgr::instance().getCOF(),
+									 link_item->getName(),
+									 description,
+									 LLAssetType::AT_LINK,
+									 NULL);
+				// Remove old link
+				gInventory.purgeObject(link_item->getUUID());
+			}
+			gAgentWearables.saveWearable(mWearablePtr->getType(), index, TRUE, new_name);
        }
 }

--- a/indra/newview/llpaneleditwearable.h
+++ b/indra/newview/llpaneleditwearable.h
@ -54,6 +54,7 @@ public:
 	/*virtual*/ BOOL 		postBuild();
 	/*virtual*/ BOOL		isDirty() const;	// LLUICtrl
 	/*virtual*/ void		draw();	
+				void		onClose();

 	// changes camera angle to default for selected subpart
 	void				changeCamera(U8 subpart);
--- a/indra/newview/llpanelpeople.cpp
+++ b/indra/newview/llpanelpeople.cpp
@ -1699,6 +1699,13 @@ void LLPanelPeople::updateButtons()

 	bool enable_calls = LLVoiceClient::getInstance()->isVoiceWorking() && LLVoiceClient::getInstance()->voiceEnabled();

+// [RLVa:KB] - Checked: 2010-06-04 (RLVa-1.2.2a) | Modified: RLVa-1.2.0d
+	if ( (nearby_tab_active) && (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) )
+	{
+		item_selected = multiple_selected = false;
+	}
+// [/RLBa:KB]
+
 // [RLVa:KB] - Checked: 2010-06-04 (RLVa-1.2.2a) | Modified: RLVa-1.2.0d
 	if ( (nearby_tab_active) && (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) )
 	{
--- a/indra/newview/llsaveoutfitcombobtn.cpp
+++ b/indra/newview/llsaveoutfitcombobtn.cpp
@ -78,8 +78,8 @@ void LLSaveOutfitComboBtn::saveOutfit(bool as_new)
 	if (panel_outfits_inventory)
 	{
 		panel_outfits_inventory->onSave();
-	} 
-	
+	} 	
+    
    if ( gAgent.getRegion() && gAgent.getRegion()->getCentralBakeVersion())
 	{
 		LLAppearanceMgr::instance().requestServerAppearanceUpdate();
--- a/indra/newview/llsidepanelappearance.cpp
+++ b/indra/newview/llsidepanelappearance.cpp
@ -231,7 +231,7 @@ void LLSidepanelAppearance::updateToVisibility(const LLSD &new_visibility)
 		{
 			gAgentCamera.changeCameraToDefault();
 			gAgentCamera.resetView();
-		}
+		}	
 		
 		if ( mEditWearable->getVisible() )
 		{
@ -380,6 +380,7 @@ void LLSidepanelAppearance::toggleOutfitEditPanel(BOOL visible, BOOL disable_cam
 		if (!disable_camera_switch)   // if we're just switching between outfit and wearable editing, don't end customization.
 		{
 			LLVOAvatarSelf::onCustomizeEnd(disable_camera_switch);
+			LLAppearanceMgr::getInstance()->setOutfitDirty( FALSE );
 		}
 	}
 }
@ -414,6 +415,7 @@ void LLSidepanelAppearance::toggleWearableEditPanel(BOOL visible, LLViewerWearab
 	{
 		// Save changes if closing.
 		mEditWearable->saveChanges();
+		LLAppearanceMgr::getInstance()->setOutfitDirty( FALSE );
 		if (!disable_camera_switch)   // if we're just switching between outfit and wearable editing, don't end customization.
 		{
 			LLVOAvatarSelf::onCustomizeEnd(disable_camera_switch);
--- a/indra/newview/llsidepanelappearance.h
+++ b/indra/newview/llsidepanelappearance.h
@ -47,7 +47,7 @@ public:
 	virtual ~LLSidepanelAppearance();

 	/*virtual*/ BOOL postBuild();
-	/*virtual*/ void onOpen(const LLSD& key);
+	/*virtual*/ void onOpen(const LLSD& key);	

 	void refreshCurrentOutfitName(const std::string& name = "");

@ -64,6 +64,7 @@ public:
 	void showDefaultSubpart();
 	void updateScrollingPanelList();
 	void updateToVisibility( const LLSD& new_visibility );
+	LLPanelEditWearable* getWearable(){ return mEditWearable; }

 // [RLVa:KB] - Checked: 2010-09-16 (RLVa-1.2.1a) | Added: RLVa-1.2.1a
 	bool isOutfitEditPanelVisible() const;
--- a/indra/newview/llsidepaneltaskinfo.cpp
+++ b/indra/newview/llsidepaneltaskinfo.cpp
@ -420,10 +420,9 @@ void LLSidepanelTaskInfo::refresh()
 // [RLVa:KB] - Checked: 2010-11-01 (RLVa-1.2.2a) | Modified: RLVa-1.2.2a
 	if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES))
 	{
-		// <FS:TM> removed for shunshine merge
-		//// Only anonymize the creator if all of the selection was created by the same avie who's also the owner or they're a nearby avie
-		//if ( (creators_identical) && (mCreatorID != gAgent.getID()) && ((mCreatorID == mOwnerID) || (RlvUtil::isNearbyAgent(mCreatorID))) )
-		//	creator_name = LLSLURL("agent", mCreatorID, "rlvanonym").getSLURLString();
+		// Only anonymize the creator if all of the selection was created by the same avie who's also the owner or they're a nearby avie
+		if ( (creators_identical) && (mCreatorID != gAgent.getID()) && ((mCreatorID == mOwnerID) || (RlvUtil::isNearbyAgent(mCreatorID))) )
+			creator_name = LLSLURL("agent", mCreatorID, "rlvanonym").getSLURLString();

 		// Only anonymize the owner name if all of the selection is owned by the same avie and isn't group owned
 		if ( (owners_identical) && (!LLSelectMgr::getInstance()->selectIsGroupOwned()) && (mOwnerID != gAgent.getID()) )
--- a/indra/newview/llslurl.cpp
+++ b/indra/newview/llslurl.cpp
@ -386,15 +386,13 @@ std::string LLSLURL::getSLURLString() const
 				S32 x = llround( (F32)mPosition[VX] );
 				S32 y = llround( (F32)mPosition[VY] );
 				S32 z = llround( (F32)mPosition[VZ] );	
-				std::string ret =  LLGridManager::getInstance()->getSLURLBase(mGrid);
-// 				ret.append(LLURI::escape(mRegion)); 
-// 				ret.append(llformat("/%d/%d/%d",x,y,z));
+//				return LLGridManager::getInstance()->getSLURLBase(mGrid) + 
+//				LLURI::escape(mRegion) + llformat("/%d/%d/%d",x,y,z); 
 // [RLVa:KB] - Checked: 2010-04-05 (RLVa-1.2.0d) | Added: RLVa-1.2.0d
-				ret.append(	( ((!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC)) || (!RlvUtil::isNearbyRegion(mRegion)))
-						? (LLURI::escape(mRegion) + llformat("/%d/%d/%d",x,y,z)) : RlvStrings::getString(RLV_STRING_HIDDEN_REGION) ));
-
+				return LLGridManager::getInstance()->getSLURLBase(mGrid) +
+					( ((!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC)) || (!RlvUtil::isNearbyRegion(mRegion)))
+						? (LLURI::escape(mRegion) + llformat("/%d/%d/%d",x,y,z)) : RlvStrings::getString(RLV_STRING_HIDDEN_REGION) );
 // [/RLVa:KB]
-				return ret;
 			}
 		case APP:
 		{
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
--- a/indra/newview/lltoolface.cpp
+++ b/indra/newview/lltoolface.cpp
@ -110,6 +110,15 @@ void LLToolFace::pickCallback(const LLPickInfo& pick_info)
 			return;
 		}

+// [RLVa:KB] - Checked: 2010-11-29 (RLVa-1.3.0c) | Modified: RLVa-1.3.0c
+		if ( (rlv_handler_t::isEnabled()) &&
+			 ( (!gRlvHandler.canEdit(hit_obj)) || 
+			   ((gRlvHandler.hasBehaviour(RLV_BHVR_FARTOUCH)) && (!gRlvHandler.canTouch(hit_obj, pick_info.mObjectOffset))) ) )
+		{
+			return;
+		}
+// [/RLVa:KB]
+
 // [RLVa:KB] - Checked: 2010-11-29 (RLVa-1.3.0c) | Modified: RLVa-1.3.0c
 		if ( (rlv_handler_t::isEnabled()) &&
 			 ( (!gRlvHandler.canEdit(hit_obj)) || 
--- a/indra/newview/lltoolpie.cpp
+++ b/indra/newview/lltoolpie.cpp
@ -1070,14 +1070,14 @@ BOOL LLToolPie::handleTooltipObject( LLViewerObject* hover_object, std::string l
 			{
 //				final_name = av_name.getCompleteName();
 // [RLVa:KB] - Checked: 2010-10-31 (RLVa-1.2.2a) | Modified: RLVa-1.2.2a
-				final_name = (!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) ? group_title+av_name.getCompleteName() : RlvStrings::getAnonym(av_name);
+				final_name = (!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) ? av_name.getCompleteName() : RlvStrings::getAnonym(av_name);
 // [/RLVa:KB]
 			}
 			else
 			{
 //				final_name = full_name;
 // [RLVa:KB] - Checked: 2010-10-31 (RLVa-1.2.2a) | Modified: RLVa-1.2.2a
-				final_name = (!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) ? group_title+full_name : RlvStrings::getAnonym(full_name);
+				final_name = (!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) ? full_name : RlvStrings::getAnonym(full_name);
 // [/RLVa:KB]
 			}

--- a/indra/newview/llviewerassetstats.cpp
+++ b/indra/newview/llviewerassetstats.cpp
@ -30,7 +30,6 @@
 #include "llregionhandle.h"

 #include "stdtypes.h"
-#include "llvoavatar.h"

 /*
 * Classes and utility functions for per-thread and per-region
@ -127,8 +126,6 @@ LLViewerAssetStats::PerRegionStats::merge(const LLViewerAssetStats::PerRegionSta
 		mFPS.merge(src.mFPS);
 	}

-	// Avatar stats - data all comes from main thread, so leave alone.
-
 	// Requests
 	for (int i = 0; i < LL_ARRAY_SIZE(mRequests); ++i)
 	{
@ -160,9 +157,7 @@ LLViewerAssetStats::LLViewerAssetStats()

 LLViewerAssetStats::LLViewerAssetStats(const LLViewerAssetStats & src)
 	: mRegionHandle(src.mRegionHandle),
-	  mResetTimestamp(src.mResetTimestamp),
-	  mPhaseStats(src.mPhaseStats),
-	  mAvatarRezStates(src.mAvatarRezStates)
+	  mResetTimestamp(src.mResetTimestamp)
 {
 	const PerRegionContainer::const_iterator it_end(src.mRegionStats.end());
 	for (PerRegionContainer::const_iterator it(src.mRegionStats.begin()); it_end != it; ++it)
@ -258,17 +253,6 @@ LLViewerAssetStats::recordFPS(F32 fps)
 	mCurRegionStats->mFPS.record(fps);
 }

-void
-LLViewerAssetStats::recordAvatarStats()
-{
-	std::vector<S32> rez_counts;
-	LLVOAvatar::getNearbyRezzedStats(rez_counts);
-	mAvatarRezStates = rez_counts;
-	mPhaseStats.clear();
-	mPhaseStats["cloud"] = LLViewerStats::PhaseMap::getPhaseStats("cloud");
-	mPhaseStats["cloud-or-gray"] = LLViewerStats::PhaseMap::getPhaseStats("cloud-or-gray");
-}
-
 LLSD
 LLViewerAssetStats::asLLSD(bool compact_output)
 {
@ -299,11 +283,6 @@ LLViewerAssetStats::asLLSD(bool compact_output)
 	static const LLSD::String max_tag("max");
 	static const LLSD::String mean_tag("mean");

-	// Avatar sub-tags
-	static const LLSD::String avatar_tag("avatar");
-	static const LLSD::String avatar_nearby_tag("nearby");
-	static const LLSD::String avatar_phase_stats_tag("phase_stats");
-	
 	const duration_t now = LLViewerAssetStatsFF::get_timestamp();
 	mCurRegionStats->accumulateTime(now);

@ -362,16 +341,6 @@ LLViewerAssetStats::asLLSD(bool compact_output)
 	LLSD ret = LLSD::emptyMap();
 	ret["regions"] = regions;
 	ret["duration"] = LLSD::Real((now - mResetTimestamp) * 1.0e-6);
-	LLSD avatar_info;
-	avatar_info[avatar_nearby_tag] = LLSD::emptyArray();
-	for (S32 rez_stat=0; rez_stat < mAvatarRezStates.size(); ++rez_stat)
-	{
-		std::string rez_status_name = LLVOAvatar::rezStatusToString(rez_stat);
-		avatar_info[avatar_nearby_tag][rez_status_name] = mAvatarRezStates[rez_stat];
-	}
-	avatar_info[avatar_phase_stats_tag]["cloud"] = mPhaseStats["cloud"].getData();
-	avatar_info[avatar_phase_stats_tag]["cloud-or-gray"] = mPhaseStats["cloud-or-gray"].getData();
-	ret[avatar_tag] = avatar_info;
 	
 	return ret;
 }
@ -470,15 +439,6 @@ record_fps_main(F32 fps)
 	gViewerAssetStatsMain->recordFPS(fps);
 }

-void
-record_avatar_stats()
-{
-	if (! gViewerAssetStatsMain)
-		return;
-
-	gViewerAssetStatsMain->recordAvatarStats();
-}
-
 // 'thread1' - should be for TextureFetch thread

 void
--- a/indra/newview/llviewerassetstats.h
+++ b/indra/newview/llviewerassetstats.h
@ -36,7 +36,6 @@
 #include "llviewerassetstorage.h"
 #include "llsimplestat.h"
 #include "llsd.h"
-#include "llvoavatar.h"

 /**
 * @class LLViewerAssetStats
@ -182,9 +181,6 @@ public:
 	// Frames-Per-Second Samples
 	void recordFPS(F32 fps);

-	// Avatar-related statistics
-	void recordAvatarStats();
-
 	// Merge a source instance into a destination instance.  This is
 	// conceptually an 'operator+=()' method:
 	// - counts are added
@ -256,10 +252,6 @@ protected:

 	// Time of last reset
 	duration_t mResetTimestamp;
-
-	// Nearby avatar stats
-	std::vector<S32> mAvatarRezStates;
-	LLViewerStats::phase_stats_t mPhaseStats;
 };


@ -318,8 +310,6 @@ void record_response_main(LLViewerAssetType::EType at, bool with_http, bool is_t

 void record_fps_main(F32 fps);

-void record_avatar_stats();
-
 /**
 * Region context, event and duration loggers for Thread 1.
 */
--- a/indra/newview/llviewerfloaterreg.cpp
+++ b/indra/newview/llviewerfloaterreg.cpp
@ -143,7 +143,9 @@
 // #include "llnearbychatbar.h"	// <FS:Zi> Remove floating chat bar

 // *NOTE: Please add files in alphabetical order to keep merges easy.
-
+// [RLVa:KB] - Checked: 2010-03-11
+#include "rlvfloaters.h"
+// [/RLVa:KB]
 // ND: And for FS please put yours after this line, for easier merges too
 #include "ao.h"
 #include "floatermedialists.h"
--- a/indra/newview/llviewermenu.cpp
+++ b/indra/newview/llviewermenu.cpp
@ -122,6 +122,10 @@
 #include "llwindow.h"
 #include "llpathfindingmanager.h"
 #include "boost/unordered_map.hpp"
+// [RLVa:KB] - Checked: 2011-05-22 (RLVa-1.3.1a)
+#include "rlvhandler.h"
+#include "rlvlocks.h"
+// [/RLVa:KB]

 // Firestorm includes
 // [RLVa:KB] - Checked: 2011-05-22 (RLVa-1.3.1a)
@ -1292,10 +1296,10 @@ class LLAdvancedToggleWireframe : public view_listener_t
 {
 	bool handleEvent(const LLSD& userdata)
 	{
-//		gUseWireframe = !(gUseWireframe);
 // [RLVa:KB] - Checked: 2010-08-22 (RLVa-1.2.1a) | Added: RLVa-1.2.1a
 		gUseWireframe = (!gUseWireframe) && (!gRlvAttachmentLocks.hasLockedHUD());
 // [/RLVa:KB]
+//		gUseWireframe = !(gUseWireframe);
 		gWindowResized = TRUE;
 		LLPipeline::updateRenderDeferred();
 		gPipeline.resetVertexBuffers();
@ -3384,9 +3388,9 @@ bool enable_object_mute()
 		bool is_linden =
 			lastname && !LLStringUtil::compareStrings(lastname->getString(), "Linden");
 		bool is_self = avatar->isSelf();
-//             return !is_linden && !is_self;
+//		return !is_linden && !is_self;
 // [RLVa:KB] - Checked: 2010-08-25 (RLVa-1.2.1b) | Added: RLVa-1.2.1b
-//             return !is_linden && !is_self && !gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES);
+		return !is_linden && !is_self && !gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES);
 // [/RLVa:KB]

 		// <FS:Zi> Make enable/disable of block/unblock menu items work for avatars
@ -7592,8 +7596,8 @@ class LLAttachmentDetachFromPoint : public view_listener_t
 // [RLVa:KB] - Checked: 2010-03-04 (RLVa-1.2.0a) | Added: RLVa-1.2.0a
 				if ( (rlv_handler_t::isEnabled()) && (gRlvAttachmentLocks.isLockedAttachment(attached_object)) )
 					continue;
-// [/RLVa:KB]
 				ids_to_remove.push_back(attached_object->getAttachmentItemID());
+// [/RLVa:KB]
 			}
 		}
 		if (!ids_to_remove.empty())
--- a/indra/newview/llviewermessage.cpp
+++ b/indra/newview/llviewermessage.cpp
@ -3501,9 +3501,9 @@ void process_improved_im(LLMessageSystem *msg, void **user_data)
 				}
 				else
 				{
-			    LLNotification::Params params("TeleportOffered");
-			    params.substitutions = args;
-			    params.payload = payload;
+					LLNotification::Params params("TeleportOffered");
+					params.substitutions = args;
+					params.payload = payload;

 // [RLVa:KB] - Checked: 2010-12-11 (RLVa-1.2.2c) | Modified: RLVa-1.2.2c
 					if ( (rlv_handler_t::isEnabled()) && ((gRlvHandler.hasBehaviour(RLV_BHVR_ACCEPTTP)) || (fRlvSummon)) )
@ -3908,7 +3908,7 @@ void process_chat_from_simulator(LLMessageSystem *msg, void **user_data)
 	LLColor4	color(1.0f, 1.0f, 1.0f, 1.0f);
 	LLUUID		from_id;
 	LLUUID		owner_id;
-	BOOL		is_owned_by_me = FALSE; //<FS:TM> readded for below rlva
+	BOOL		is_owned_by_me = FALSE;
 	LLViewerObject*	chatter;

 	msg->getString("ChatData", "FromName", from_name);
@ -3962,26 +3962,7 @@ void process_chat_from_simulator(LLMessageSystem *msg, void **user_data)
 	}
 	else
 	{
-		//chat.mFromName = from_name;
-		// objects with no name get renamed to NO_NAME_OBJECT so the object profile is still accessable - KC
-		static const boost::regex whitespace_exp("^\\s*$");
-		if (chat.mSourceType == CHAT_SOURCE_OBJECT && boost::regex_search(from_name, whitespace_exp))
-		{
-			//[FIRE-2434 Mark Unamed Objects based on setting
-			static LLCachedControl<bool> FSMarkObjects(gSavedSettings, "FSMarkObjects");
-			if (FSMarkObjects)
-			{
-				chat.mFromName = LLTrans::getString("no_name_object");
-			}
-			else
-			{
-				chat.mFromName = "";
-			}
-		}
-		else
-		{
-			chat.mFromName = from_name;
-		}
+		chat.mFromName = from_name;
 	}

 	BOOL is_busy = gAgent.getBusy();
@ -4133,6 +4114,75 @@ void process_chat_from_simulator(LLMessageSystem *msg, void **user_data)
 		}
 // [/RLVa:KB]

+// [RLVa:KB] - Checked: 2010-04-23 (RLVa-1.2.0f) | Modified: RLVa-1.2.0f
+		if ( (rlv_handler_t::isEnabled()) && (CHAT_TYPE_START != chat.mChatType) && (CHAT_TYPE_STOP != chat.mChatType) )
+		{
+			// NOTE: chatter can be NULL (may not have rezzed yet, or could be another avie's HUD attachment)
+			BOOL is_attachment = (chatter) ? chatter->isAttachment() : FALSE;
+			BOOL is_owned_by_me = (chatter) ? chatter->permYouOwner() : FALSE;
+
+			// Filtering "rules":
+			//   avatar  => filter all avie text (unless it's this avie or they're an exemption)
+			//   objects => filter everything except attachments this avie owns (never filter llOwnerSay chat)
+			if ( ( (CHAT_SOURCE_AGENT == chat.mSourceType) && (from_id != gAgent.getID()) ) || 
+				 ( (CHAT_SOURCE_OBJECT == chat.mSourceType) && ((!is_owned_by_me) || (!is_attachment)) && 
+				   (CHAT_TYPE_OWNER != chat.mChatType) ) )
+			{
+				bool fIsEmote = RlvUtil::isEmote(mesg);
+				if ((!fIsEmote) &&
+					(((gRlvHandler.hasBehaviour(RLV_BHVR_RECVCHAT)) && (!gRlvHandler.isException(RLV_BHVR_RECVCHAT, from_id))) ||
+					 ((gRlvHandler.hasBehaviour(RLV_BHVR_RECVCHATFROM)) && (gRlvHandler.isException(RLV_BHVR_RECVCHATFROM, from_id))) ))
+				{
+					if ( (gRlvHandler.filterChat(mesg, false)) && (!gSavedSettings.getBOOL("RestrainedLoveShowEllipsis")) )
+						return;
+				}
+				else if ((fIsEmote) &&
+					     (((gRlvHandler.hasBehaviour(RLV_BHVR_RECVEMOTE)) && (!gRlvHandler.isException(RLV_BHVR_RECVEMOTE, from_id))) ||
+					      ((gRlvHandler.hasBehaviour(RLV_BHVR_RECVEMOTEFROM)) && (gRlvHandler.isException(RLV_BHVR_RECVEMOTEFROM, from_id))) ))
+ 				{
+					if (!gSavedSettings.getBOOL("RestrainedLoveShowEllipsis"))
+						return;
+					mesg = "/me ...";
+				}
+			}
+
+			// Filtering "rules":
+			//   avatar => filter only their name (unless it's this avie)
+			//   other  => filter everything
+			if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES))
+			{
+				if (CHAT_SOURCE_AGENT != chat.mSourceType)
+				{
+					RlvUtil::filterNames(chat.mFromName);
+				}
+				else if (chat.mFromID != gAgent.getID())
+				{
+					chat.mFromName = RlvStrings::getAnonym(chat.mFromName);
+					chat.mRlvNamesFiltered = TRUE;
+				} 
+			}
+
+			// Create an "objectim" URL for objects if we're either @shownames or @showloc restricted
+			// (we need to do this now because we won't be have enough information to do it later on)
+			if ( (CHAT_SOURCE_OBJECT == chat.mSourceType) && 
+				 ((gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) || (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC))) )
+			{
+				LLSD sdQuery;
+				sdQuery["name"] = chat.mFromName;
+				sdQuery["owner"] = owner_id;
+
+				if ( (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) && (!is_owned_by_me) )
+					sdQuery["rlv_shownames"] = true;
+
+				const LLViewerRegion* pRegion = LLWorld::getInstance()->getRegionFromPosAgent(chat.mPosAgent);
+				if (pRegion)
+					sdQuery["slurl"] = LLSLURL(pRegion->getName(), chat.mPosAgent).getLocationString();
+
+				chat.mURL = LLSLURL("objectim", from_id, LLURI::mapToQueryString(sdQuery)).getSLURLString();
+			}
+		}
+// [/RLVa:KB]
+
 		BOOL ircstyle = FALSE;

 		// Look for IRC-style emotes here so chatbubbles work
@ -4198,13 +4248,13 @@ void process_chat_from_simulator(LLMessageSystem *msg, void **user_data)
 					}
 				}
 //-TT
+
 // [RLVa:KB] - Checked: 2010-02-XX (RLVa-1.2.0a) | Modified: RLVa-1.1.0f
 				// TODO-RLVa: [RLVa-1.2.0] consider rewriting this before a RLVa-1.2.0 release
 				if ( (rlv_handler_t::isEnabled()) && (mesg.length() > 3) && (RLV_CMD_PREFIX == mesg[0]) && (CHAT_TYPE_OWNER == chat.mChatType) )
 				{
 					mesg.erase(0, 1);
 					LLStringUtil::toLower(mesg);
-					allowConvertChatUppercase = false;

 					std::string strExecuted, strFailed, strRetained, *pstr;

@ -4281,7 +4331,6 @@ void process_chat_from_simulator(LLMessageSystem *msg, void **user_data)
 				if  ( (rlv_handler_t::isEnabled()) && (chatter) && (chat.mSourceType == CHAT_SOURCE_OBJECT) &&
 					  (gSavedSettings.getBOOL("EffectScriptChatParticles")) )
 				{
-					allowConvertChatUppercase = false;
 					LLPointer<LLViewerPartSourceChat> psc = new LLViewerPartSourceChat(chatter->getPositionAgent());
 					psc->setSourceObject(chatter);
 					psc->setColor(color);
--- a/indra/newview/llviewerobject.cpp
+++ b/indra/newview/llviewerobject.cpp
@ -4105,38 +4105,15 @@ void LLViewerObject::setTEImage(const U8 te, LLViewerTexture *imagep)
 	}
 }

-
-S32 LLViewerObject::setTETextureCore(const U8 te, const LLUUID& uuid, const std::string &url )
+S32 LLViewerObject::setTETextureCore(const U8 te, LLViewerTexture *image)
 {
+	const LLUUID& uuid = image->getID();
 	S32 retval = 0;
 	if (uuid != getTE(te)->getID() ||
 		uuid == LLUUID::null)
 	{
 		retval = LLPrimitive::setTETexture(te, uuid);
-		mTEImages[te] = LLViewerTextureManager::getFetchedTextureFromUrl  (url, TRUE, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE, 0, 0, uuid);
-		setChanged(TEXTURE);
-		if (mDrawable.notNull())
-		{
-			gPipeline.markTextured(mDrawable);
-		}
-	}
-	return retval;
-}
-
-S32 LLViewerObject::setTETextureCore(const U8 te, const LLUUID& uuid, LLHost host)
-{
-	S32 retval = 0;
-	if (uuid != getTE(te)->getID() ||
-		uuid == LLUUID::null)
-	{
-		retval = LLPrimitive::setTETexture(te, uuid);
-		mTEImages[te] = LLViewerTextureManager::getFetchedTexture(uuid, TRUE, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE, 0, 0, host);
-
-		// <FS:ND> Debug aid <ND:TODO> Remove again
-		if( !ndIsValidPtr( mTEImages[te].get() ) &&  mTEImages[te].get() != 0 )
-			llerrs << "Set invalid pointer to mTEImages" << llendl;
-		// </FS:ND>
-
+		mTEImages[te] = image;
 		setChanged(TEXTURE);
 		if (mDrawable.notNull())
 		{
@ -4162,7 +4139,9 @@ void LLViewerObject::changeTEImage(S32 index, LLViewerTexture* new_image)
 S32 LLViewerObject::setTETexture(const U8 te, const LLUUID& uuid)
 {
 	// Invalid host == get from the agent's sim
-	return setTETextureCore(te, uuid, LLHost::invalid);
+	LLViewerFetchedTexture *image = LLViewerTextureManager::getFetchedTexture(
+		uuid, TRUE, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE, 0, 0, LLHost::invalid);
+	return setTETextureCore(te,image);
 }


--- a/indra/newview/llviewerobject.h
+++ b/indra/newview/llviewerobject.h
@ -304,7 +304,7 @@ public:
 	/*virtual*/	void	setNumTEs(const U8 num_tes);
 	/*virtual*/	void	setTE(const U8 te, const LLTextureEntry &texture_entry);
 	/*virtual*/ S32		setTETexture(const U8 te, const LLUUID &uuid);
-	S32 setTETextureCore(const U8 te, const LLUUID& uuid, LLHost host);
+	S32 				setTETextureCore(const U8 te, LLViewerTexture *image);
 	S32 setTETextureCore(const U8 te, const LLUUID& uuid, const std::string &url );
 	/*virtual*/ S32		setTEColor(const U8 te, const LLColor3 &color);
 	/*virtual*/ S32		setTEColor(const U8 te, const LLColor4 &color);
--- a/indra/newview/llviewerstats.cpp
+++ b/indra/newview/llviewerstats.cpp
@ -733,23 +733,27 @@ void send_stats()
 	LLHTTPClient::post(url, body, new ViewerStatsResponder());
 }

-LLFrameTimer& LLViewerStats::PhaseMap::getPhaseTimer(const std::string& phase_name)
+LLViewerStats::PhaseMap::PhaseMap()
+{
+}
+
+LLTimer& LLViewerStats::PhaseMap::getPhaseTimer(const std::string& phase_name)
 {
 	phase_map_t::iterator iter = mPhaseMap.find(phase_name);
 	if (iter == mPhaseMap.end())
 	{
-		LLFrameTimer timer;
+		LLTimer timer;
 		mPhaseMap[phase_name] = timer;
 	}
-	LLFrameTimer& timer = mPhaseMap[phase_name];
+	LLTimer& timer = mPhaseMap[phase_name];
 	return timer;
 }

 void LLViewerStats::PhaseMap::startPhase(const std::string& phase_name)
 {
-	LLFrameTimer& timer = getPhaseTimer(phase_name);
+	LLTimer& timer = getPhaseTimer(phase_name);
 	lldebugs << "startPhase " << phase_name << llendl;
-	timer.unpause();
+	timer.start();
 }

 void LLViewerStats::PhaseMap::stopPhase(const std::string& phase_name)
@ -759,34 +763,27 @@ void LLViewerStats::PhaseMap::stopPhase(const std::string& phase_name)
 	{
 		if (iter->second.getStarted())
 		{
-			// Going from started to paused state - record stats.
-			recordPhaseStat(phase_name,iter->second.getElapsedTimeF32());
+			// Going from started to stopped state - record stats.
+			iter->second.stop();
 		}
-		lldebugs << "stopPhase " << phase_name << llendl;
-		iter->second.pause();
+	}
+}
+
+bool LLViewerStats::PhaseMap::getPhaseValues(const std::string& phase_name, F32& elapsed, bool& completed)
+{
+	phase_map_t::iterator iter = mPhaseMap.find(phase_name);
+	if (iter != mPhaseMap.end())
+	{
+		elapsed =  iter->second.getElapsedTimeF32();
+		completed = !iter->second.getStarted();
+		return true;
 	}
 	else
 	{
-		lldebugs << "stopPhase " << phase_name << " is not started, no-op" << llendl;
+		return false;
 	}
 }
-
-void LLViewerStats::PhaseMap::stopAllPhases()
-{
-	for (phase_map_t::iterator iter = mPhaseMap.begin();
-		 iter != mPhaseMap.end(); ++iter)
-	{
-		const std::string& phase_name = iter->first;
-		if (iter->second.getStarted())
-		{
-			// Going from started to paused state - record stats.
-			recordPhaseStat(phase_name,iter->second.getElapsedTimeF32());
-		}
-		lldebugs << "stopPhase (all) " << phase_name << llendl;
-		iter->second.pause();
-	}
-}
-
+	
 void LLViewerStats::PhaseMap::clearPhases()
 {
 	lldebugs << "clearPhases" << llendl;
@ -805,31 +802,3 @@ LLSD LLViewerStats::PhaseMap::dumpPhases()
 	}
 	return result;
 }
-
-// static initializer
-//static
-LLViewerStats::phase_stats_t LLViewerStats::PhaseMap::sStats;
-
-LLViewerStats::PhaseMap::PhaseMap()
-{
-}
-
-// static
-LLViewerStats::StatsAccumulator& LLViewerStats::PhaseMap::getPhaseStats(const std::string& phase_name)
-{
-	phase_stats_t::iterator it = sStats.find(phase_name);
-	if (it == sStats.end())
-	{
-		LLViewerStats::StatsAccumulator new_stats;
-		sStats[phase_name] = new_stats;
-	}
-	return sStats[phase_name];
-}
-
-// static
-void LLViewerStats::PhaseMap::recordPhaseStat(const std::string& phase_name, F32 value)
-{
-	LLViewerStats::StatsAccumulator& stats = getPhaseStats(phase_name);
-	stats.push(value);
-}
-
--- a/indra/newview/llviewerstats.h
+++ b/indra/newview/llviewerstats.h
@ -279,23 +279,22 @@ public:

 	// Phase tracking (originally put in for avatar rezzing), tracking
 	// progress of active/completed phases for activities like outfit changing.
-	typedef std::map<std::string,LLFrameTimer>	phase_map_t;
+	typedef std::map<std::string,LLTimer>	phase_map_t;
 	typedef std::map<std::string,StatsAccumulator>	phase_stats_t;
 	class PhaseMap
 	{
 	private:
 		phase_map_t mPhaseMap;
-		static phase_stats_t sStats;
 	public:
 		PhaseMap();
-		LLFrameTimer& 	getPhaseTimer(const std::string& phase_name);
+		LLTimer&	 	getPhaseTimer(const std::string& phase_name);
+		bool 			getPhaseValues(const std::string& phase_name, F32& elapsed, bool& completed);
 		void			startPhase(const std::string& phase_name);
 		void			stopPhase(const std::string& phase_name);
-		void			stopAllPhases();
 		void			clearPhases();
 		LLSD			dumpPhases();
-		static StatsAccumulator& getPhaseStats(const std::string& phase_name);
-		static void recordPhaseStat(const std::string& phase_name, F32 value);
+		phase_map_t::iterator begin() { return mPhaseMap.begin(); }
+		phase_map_t::iterator end() { return mPhaseMap.end(); }
 	};

 private:
--- a/indra/newview/llviewertexture.cpp
+++ b/indra/newview/llviewertexture.cpp
@ -615,6 +615,7 @@ LLViewerTexture::LLViewerTexture(const LLImageRaw* raw, BOOL usemipmaps) :

 LLViewerTexture::~LLViewerTexture()
 {
+	// LL_DEBUGS("Avatar") << mID << llendl;
 	cleanup();
 	sImageCount--;
 }
@ -1174,7 +1175,8 @@ void LLViewerFetchedTexture::destroyTexture()
 	{
 		return ;
 	}
-	
+
+	//LL_DEBUGS("Avatar") << mID << llendl;
 	destroyGLTexture() ;
 	mFullyLoaded = FALSE ;
 }
--- a/indra/newview/llviewertexture.h
+++ b/indra/newview/llviewertexture.h
@ -134,6 +134,7 @@ public:
 	void resetTextureStats();	
 	void setMaxVirtualSizeResetInterval(S32 interval)const {mMaxVirtualSizeResetInterval = interval;}
 	void resetMaxVirtualSizeResetCounter()const {mMaxVirtualSizeResetCounter = mMaxVirtualSizeResetInterval;}
+	S32 getMaxVirtualSizeResetCounter() const { return mMaxVirtualSizeResetCounter; }

 	virtual F32  getMaxVirtualSize() ;

@ -327,6 +328,7 @@ public:
 	// the priority list, and cause horrible things to happen.
 	void setDecodePriority(F32 priority = -1.0f);
 	F32 getDecodePriority() const { return mDecodePriority; };
+	F32 getAdditionalDecodePriority() const { return mAdditionalDecodePriority; };

 	void setAdditionalDecodePriority(F32 priority) ;
 	
--- a/indra/newview/llviewertexturelist.cpp
+++ b/indra/newview/llviewertexturelist.cpp
@ -374,7 +374,24 @@ LLViewerFetchedTexture* LLViewerTextureList::getImageFromUrl(const std::string&
 	}

 	LLPointer<LLViewerFetchedTexture> imagep = findImage(new_id);
-	
+
+	if (!imagep.isNull())
+	{
+		LLViewerFetchedTexture *texture = imagep.get();
+		if (texture->getUrl().empty())
+		{
+			llwarns << "Requested texture " << new_id << " already exists but does not have a URL" << llendl;
+		}
+		else if (texture->getUrl() != url)
+		{
+			// This is not an error as long as the images really match -
+			// e.g. could be two avatars wearing the same outfit.
+			LL_DEBUGS("Avatar") << "Requested texture " << new_id
+								<< " already exists with a different url, requested: " << url
+								<< " current: " << texture->getUrl() << llendl;
+		}
+		
+	}
 	if (imagep.isNull())
 	{
 		switch(texture_type)
@ -436,7 +453,23 @@ LLViewerFetchedTexture* LLViewerTextureList::getImage(const LLUUID &image_id,
 	}
 	
 	LLPointer<LLViewerFetchedTexture> imagep = findImage(image_id);
-	
+	if (!imagep.isNull())
+	{
+		LLViewerFetchedTexture *texture = imagep.get();
+		if (request_from_host.isOk() &&
+			!texture->getTargetHost().isOk())
+		{
+			llwarns << "Requested texture " << image_id << " already exists but does not have a host" << llendl;
+		}
+		else if (request_from_host.isOk() &&
+				 texture->getTargetHost().isOk() &&
+				 request_from_host != texture->getTargetHost())
+		{
+			llwarns << "Requested texture " << image_id << " already exists with a different target host, requested: " 
+					<< request_from_host << " current: " << texture->getTargetHost() << llendl;
+		}
+		
+	}
 	if (imagep.isNull())
 	{
 		imagep = createImage(image_id, usemipmaps, boost_priority, texture_type, internal_format, primary_format, request_from_host) ;
--- a/indra/newview/llviewerwindow.cpp
+++ b/indra/newview/llviewerwindow.cpp
--- a/indra/newview/llvoavatar.cpp
+++ b/indra/newview/llvoavatar.cpp
--- a/indra/newview/llvoavatar.h
+++ b/indra/newview/llvoavatar.h
@ -70,6 +70,7 @@ class LLHUDNameTag;
 class LLHUDEffectSpiral;
 class LLTexGlobalColor;
 class LLViewerJoint;
+struct LLAppearanceMessageContents;

 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // LLVOAvatar
@ -125,17 +126,29 @@ protected:
 public:
 	/*virtual*/ void			updateGL();
 	/*virtual*/ LLVOAvatar*		asAvatar();
-	virtual U32    	 	 	processUpdateMessage(LLMessageSystem *mesgsys,
+	virtual U32    	 	 		processUpdateMessage(LLMessageSystem *mesgsys,
 													 void **user_data,
 													 U32 block_num,
 													 const EObjectUpdateType update_type,
 													 LLDataPacker *dp);
-	virtual void   	 	 	idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time);
+	virtual void   	 	 		idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time);
 	/*virtual*/ BOOL   	 	 	updateLOD();
-	BOOL  	 	 	 	 	updateJointLODs();
-	void					updateLODRiggedAttachments( void );
+	BOOL  	 	 	 	 		updateJointLODs();
+	void						updateLODRiggedAttachments( void );
 	/*virtual*/ BOOL   	 	 	isActive() const; // Whether this object needs to do an idleUpdate.
+	S32 						totalTextureMemForUUIDS(std::set<LLUUID>& ids);
+	bool 						allTexturesCompletelyDownloaded(std::set<LLUUID>& ids) const;
+	bool 						allLocalTexturesCompletelyDownloaded() const;
+	bool 						allBakedTexturesCompletelyDownloaded() const;
+	void 						bakedTextureOriginCounts(S32 &sb_count, S32 &host_count,
+														 S32 &both_count, S32 &neither_count);
+	std::string 				bakedTextureOriginInfo();
+	void 						collectLocalTextureUUIDs(std::set<LLUUID>& ids) const;
+	void 						collectBakedTextureUUIDs(std::set<LLUUID>& ids) const;
+	void 						collectTextureUUIDs(std::set<LLUUID>& ids);
+	void						releaseOldTextures();
 	/*virtual*/ void   	 	 	updateTextures();
+	LLViewerFetchedTexture*		getBakedTextureImage(const U8 te, const LLUUID& uuid);
 	/*virtual*/ S32    	 	 	setTETexture(const U8 te, const LLUUID& uuid); // If setting a baked texture, need to request it from a non-local sim.
 	/*virtual*/ void   	 	 	onShift(const LLVector4a& shift_vector);
 	/*virtual*/ U32    	 	 	getPartitionType() const;
@ -277,17 +290,21 @@ public:
 	virtual BOOL	getIsCloud() const;
 	BOOL			isFullyTextured() const;
 	BOOL			hasGray() const; 
-	S32				getRezzedStatus() const; // 0 = cloud, 1 = gray, 2 = fully textured.
+	S32				getRezzedStatus() const; // 0 = cloud, 1 = gray, 2 = textured, 3 = textured and fully downloaded.
 	void			updateRezzedStatusTimers();

 	S32				mLastRezzedStatus;

-	LLViewerStats::PhaseMap& getPhases()
-	{
-		return mPhases;
-	}
+	
+	void 			startPhase(const std::string& phase_name);
+	void 			stopPhase(const std::string& phase_name, bool err_check = true);
+	void			clearPhases();
+	void 			logPendingPhases();
+	static void 	logPendingPhasesAllAvatars();
+	void 			logMetricsTimerRecord(const std::string& phase_name, F32 elapsed, bool completed);

 protected:
+	LLViewerStats::PhaseMap& getPhases() { return mPhases; }
 	BOOL			updateIsFullyLoaded();
 	BOOL			processFullyLoadedChange(bool loading);
 	void			updateRuthTimer(bool loading);
@ -302,24 +319,6 @@ private:
 	LLFrameTimer	mFullyLoadedTimer;
 	LLFrameTimer	mRuthTimer;

-public:
-	class ScopedPhaseSetter
-	{
-	public:
-		ScopedPhaseSetter(LLVOAvatar *avatarp, std::string phase_name):
-			mAvatar(avatarp), mPhaseName(phase_name)
-		{
-			if (mAvatar) { mAvatar->getPhases().startPhase(mPhaseName); }
-		}
-		~ScopedPhaseSetter()
-		{
-			if (mAvatar) { mAvatar->getPhases().stopPhase(mPhaseName); }
-		}
-	private:
-		std::string mPhaseName;
-		LLVOAvatar* mAvatar;
-	};
-
 private:
 	LLViewerStats::PhaseMap mPhases;

@ -531,6 +530,7 @@ protected:

 	LLLoadedCallbackEntry::source_callback_list_t mCallbackTextureList ; 
 	BOOL mLoadedCallbacksPaused;
+	std::set<LLUUID>	mTextureIDs;
 	//--------------------------------------------------------------------
 	// Local Textures
 	//--------------------------------------------------------------------
@ -629,6 +629,7 @@ protected:
 **/

 public:
+	void 			parseAppearanceMessage(LLMessageSystem* mesgsys, LLAppearanceMessageContents& msg);
 	void 			processAvatarAppearance(LLMessageSystem* mesgsys);
 	void 			hideSkirt();
 	void			startAppearanceAnimation();
@ -647,7 +648,7 @@ public:

 	// True if this avatar should fetch its baked textures via the new
 	// appearance mechanism.
-	/*virtual*/ BOOL	isUsingServerBakes() const { return mUseServerBakes; }
+	BOOL				isUsingServerBakes() const;
 	void 				setIsUsingServerBakes(BOOL newval);


--- a/indra/newview/llvoavatarself.cpp
+++ b/indra/newview/llvoavatarself.cpp
@ -74,6 +74,7 @@
 #include "llvovolume.h"
 #include "llsdutil.h"
 #include "llstartup.h"
+#include "llsdserialize.h"
 // [RLVa:KB] - Checked: 2011-05-22 (RLVa-1.3.1a)
 #include "rlvhandler.h"
 #include "rlvlocks.h"
@ -97,15 +98,15 @@ void selfStartPhase(const std::string& phase_name)
 {
 	if (isAgentAvatarValid())
 	{
-		gAgentAvatarp->getPhases().startPhase(phase_name);
+		gAgentAvatarp->startPhase(phase_name);
 	}
 }

-void selfStopPhase(const std::string& phase_name)
+void selfStopPhase(const std::string& phase_name, bool err_check)
 {
 	if (isAgentAvatarValid())
 	{
-		gAgentAvatarp->getPhases().stopPhase(phase_name);
+		gAgentAvatarp->stopPhase(phase_name, err_check);
 	}
 }

@ -113,16 +114,7 @@ void selfClearPhases()
 {
 	if (isAgentAvatarValid())
 	{
-		gAgentAvatarp->getPhases().clearPhases();
-		gAgentAvatarp->mLastRezzedStatus = -1;
-	}
-}
-
-void selfStopAllPhases()
-{
-	if (isAgentAvatarValid())
-	{
-		gAgentAvatarp->getPhases().stopAllPhases();
+		gAgentAvatarp->clearPhases();
 	}
 }

@ -195,6 +187,35 @@ LLVOAvatarSelf::LLVOAvatarSelf(const LLUUID& id,
 	lldebugs << "Marking avatar as self " << id << llendl;
 }

+// Called periodically for diagnostics, return true when done.
+bool output_self_av_texture_diagnostics()
+{
+	if (!isAgentAvatarValid())
+		return true; // done checking
+
+	gAgentAvatarp->outputRezDiagnostics();
+
+	return false;
+}
+
+bool update_avatar_rez_metrics()
+{
+	if (!isAgentAvatarValid())
+		return true;
+	
+	gAgentAvatarp->updateAvatarRezMetrics(false);
+	return false;
+}
+
+bool check_for_unsupported_baked_appearance()
+{
+	if (!isAgentAvatarValid())
+		return true;
+
+	gAgentAvatarp->checkForUnsupportedServerBakeAppearance();
+	return false;
+}
+
 void LLVOAvatarSelf::initInstance()
 {
 	BOOL status = TRUE;
@ -232,6 +253,10 @@ void LLVOAvatarSelf::initInstance()
 		llerrs << "Unable to load user's avatar" << llendl;
 		return;
 	}
+
+	//doPeriodically(output_self_av_texture_diagnostics, 30.0);
+	doPeriodically(update_avatar_rez_metrics, 5.0);
+	doPeriodically(check_for_unsupported_baked_appearance, 120.0);
 }

 // virtual
@ -975,6 +1000,15 @@ U32  LLVOAvatarSelf::processUpdateMessage(LLMessageSystem *mesgsys,
 {
 	U32 retval = LLVOAvatar::processUpdateMessage(mesgsys,user_data,block_num,update_type,dp);

+#if 0
+	// DRANO - it's not clear this does anything useful. If we wait
+	// until an appearance message has been received, we already have
+	// the texture ids. If we don't wait, we don't yet know where to
+	// look for baked textures, because we haven't received the
+	// appearance version data from the appearance message. This looks
+	// like an old optimization that's incompatible with server-side
+	// texture baking.
+	
 	// FIXME DRANO - skipping in the case of !mFirstAppearanceMessageReceived prevents us from trying to
 	// load textures before we know where they come from (ie, from baking service or not);
 	// unknown impact on performance.
@ -999,6 +1033,7 @@ U32  LLVOAvatarSelf::processUpdateMessage(LLMessageSystem *mesgsys,

 		mInitialBakesLoaded = true;
 	}
+#endif

 	return retval;
 }
@ -1442,7 +1477,7 @@ const LLViewerJointAttachment *LLVOAvatarSelf::attachObject(LLViewerObject *view
 		}
 // [/RLVa:KB]
 	}
-	
+
 	return attachment;
 }

@ -1738,7 +1773,9 @@ BOOL LLVOAvatarSelf::isLocalTextureDataFinal(const LLViewerTexLayerSet* layerset
 				const U32 wearable_count = gAgentWearables.getWearableCount(wearable_type);
 				for (U32 wearable_index = 0; wearable_index < wearable_count; wearable_index++)
 				{
-					if (getLocalDiscardLevel(*local_tex_iter, wearable_index) > (S32)(desired_tex_discard_level))
+					S32 local_discard_level = getLocalDiscardLevel(*local_tex_iter, wearable_index);
+					if ((local_discard_level > (S32)(desired_tex_discard_level)) ||
+						(local_discard_level < 0 ))
 					{
 						return FALSE;
 					}
@ -1751,6 +1788,7 @@ BOOL LLVOAvatarSelf::isLocalTextureDataFinal(const LLViewerTexLayerSet* layerset
 	return FALSE;
 }

+
 BOOL LLVOAvatarSelf::isAllLocalTextureDataFinal() const
 {
 	const U32 desired_tex_discard_level = gSavedSettings.getU32("TextureDiscardLevel"); 
@ -1768,7 +1806,9 @@ BOOL LLVOAvatarSelf::isAllLocalTextureDataFinal() const
 			const U32 wearable_count = gAgentWearables.getWearableCount(wearable_type);
 			for (U32 wearable_index = 0; wearable_index < wearable_count; wearable_index++)
 			{
-				if (getLocalDiscardLevel(*local_tex_iter, wearable_index) > (S32)(desired_tex_discard_level))
+				S32 local_discard_level = getLocalDiscardLevel(*local_tex_iter, wearable_index);
+				if ((local_discard_level > (S32)(desired_tex_discard_level)) ||
+					(local_discard_level < 0 ))
 				{
 					return FALSE;
 				}
@ -2331,6 +2371,84 @@ void LLVOAvatarSelf::debugBakedTextureUpload(EBakedTextureIndex index, BOOL fini
 	mDebugBakedTextureTimes[index][done] = mDebugSelfLoadTimer.getElapsedTimeF32();
 }

+const std::string LLVOAvatarSelf::verboseDebugDumpLocalTextureDataInfo(const LLViewerTexLayerSet* layerset) const
+{
+	std::ostringstream outbuf;
+	for (LLAvatarAppearanceDictionary::BakedTextures::const_iterator baked_iter =
+			 LLAvatarAppearanceDictionary::getInstance()->getBakedTextures().begin();
+		 baked_iter != LLAvatarAppearanceDictionary::getInstance()->getBakedTextures().end();
+		 ++baked_iter)
+	{
+		const EBakedTextureIndex baked_index = baked_iter->first;
+		if (layerset == mBakedTextureDatas[baked_index].mTexLayerSet)
+		{
+			outbuf << "baked_index: " << baked_index << "\n";
+			const LLAvatarAppearanceDictionary::BakedEntry *baked_dict = baked_iter->second;
+			for (texture_vec_t::const_iterator local_tex_iter = baked_dict->mLocalTextures.begin();
+				 local_tex_iter != baked_dict->mLocalTextures.end();
+				 ++local_tex_iter)
+			{
+				const ETextureIndex tex_index = *local_tex_iter;
+				const std::string tex_name = LLAvatarAppearanceDictionary::getInstance()->getTexture(tex_index)->mName;
+				outbuf << "  tex_index " << (S32) tex_index << " name " << tex_name << "\n";
+				const LLWearableType::EType wearable_type = LLAvatarAppearanceDictionary::getTEWearableType(tex_index);
+				const U32 wearable_count = gAgentWearables.getWearableCount(wearable_type);
+				if (wearable_count > 0)
+				{
+					for (U32 wearable_index = 0; wearable_index < wearable_count; wearable_index++)
+					{
+						outbuf << "    " << LLWearableType::getTypeName(wearable_type) << " " << wearable_index << ":";
+						const LLLocalTextureObject *local_tex_obj = getLocalTextureObject(tex_index, wearable_index);
+						if (local_tex_obj)
+						{
+							LLViewerFetchedTexture* image = dynamic_cast<LLViewerFetchedTexture*>( local_tex_obj->getImage() );
+							if (tex_index >= 0
+								&& local_tex_obj->getID() != IMG_DEFAULT_AVATAR
+								&& !image->isMissingAsset())
+							{
+								outbuf << " id: " << image->getID()
+									   << " refs: " << image->getNumRefs()
+									   << " glocdisc: " << getLocalDiscardLevel(tex_index, wearable_index)
+									   << " discard: " << image->getDiscardLevel()
+									   << " desired: " << image->getDesiredDiscardLevel()
+									   << " decode: " << image->getDecodePriority()
+									   << " addl: " << image->getAdditionalDecodePriority()
+									   << " ts: " << image->getTextureState()
+									   << " bl: " << image->getBoostLevel()
+									   << " fl: " << image->isFullyLoaded() // this is not an accessor for mFullyLoaded - see comment there.
+									   << " cl: " << (image->isFullyLoaded() && image->getDiscardLevel()==0) // "completely loaded"
+									   << " mvs: " << image->getMaxVirtualSize()
+									   << " mvsc: " << image->getMaxVirtualSizeResetCounter()
+									   << " mem: " << image->getTextureMemory();
+							}
+						}
+						outbuf << "\n";
+					}
+				}
+			}
+			break;
+		}
+	}
+	return outbuf.str();
+}
+
+void LLVOAvatarSelf::dumpAllTextures() const
+{
+	std::string vd_text = "Local textures per baked index and wearable:\n";
+	for (LLAvatarAppearanceDefines::LLAvatarAppearanceDictionary::BakedTextures::const_iterator baked_iter = LLAvatarAppearanceDefines::LLAvatarAppearanceDictionary::getInstance()->getBakedTextures().begin();
+		 baked_iter != LLAvatarAppearanceDefines::LLAvatarAppearanceDictionary::getInstance()->getBakedTextures().end();
+		 ++baked_iter)
+	{
+		const LLAvatarAppearanceDefines::EBakedTextureIndex baked_index = baked_iter->first;
+		const LLViewerTexLayerSet *layerset = debugGetLayerSet(baked_index);
+		if (!layerset) continue;
+		const LLViewerTexLayerSetBuffer *layerset_buffer = layerset->getViewerComposite();
+		if (!layerset_buffer) continue;
+		vd_text += verboseDebugDumpLocalTextureDataInfo(layerset);
+	}
+	LL_DEBUGS("Avatar") << vd_text << llendl;
+}
+
 const std::string LLVOAvatarSelf::debugDumpLocalTextureDataInfo(const LLViewerTexLayerSet* layerset) const
 {
 	std::string text="";
@ -2399,20 +2517,14 @@ const std::string LLVOAvatarSelf::debugDumpAllLocalTextureDataInfo() const
 	return text;
 }

+
+#if 0
 // Dump avatar metrics data.
 LLSD LLVOAvatarSelf::metricsData()
 {
 	// runway - add region info
 	LLSD result;
 	result["rez_status"] = LLVOAvatar::rezStatusToString(getRezzedStatus());
-	std::vector<S32> rez_counts;
-	LLVOAvatar::getNearbyRezzedStats(rez_counts);
-	result["nearby"] = LLSD::emptyMap();
-	for (S32 i=0; i<rez_counts.size(); ++i)
-	{
-		std::string rez_status_name = LLVOAvatar::rezStatusToString(i);
-		result["nearby"][rez_status_name] = rez_counts[i];
-	}
 	result["timers"]["debug_existence"] = mDebugExistenceTimer.getElapsedTimeF32();
 	result["timers"]["ruth_debug"] = mRuthDebugTimer.getElapsedTimeF32();
 	result["timers"]["ruth"] = mRuthTimer.getElapsedTimeF32();
@ -2422,6 +2534,7 @@ LLSD LLVOAvatarSelf::metricsData()
 	
 	return result;
 }
+#endif

 class ViewerAppearanceChangeMetricsResponder: public LLCurl::Responder
 {
@ -2471,19 +2584,121 @@ private:
 	volatile bool & mReportingStarted;
 };

-void LLVOAvatarSelf::sendAppearanceChangeMetrics()
+bool LLVOAvatarSelf::updateAvatarRezMetrics(bool force_send)
+{
+	const F32 AV_METRICS_INTERVAL_QA = 30.0;
+	F32 send_period = 300.0;
+	if (gSavedSettings.getBOOL("QAModeMetrics"))
+	{
+		send_period = AV_METRICS_INTERVAL_QA;
+	}
+
+	if (force_send || mTimeSinceLastRezMessage.getElapsedTimeF32() > send_period)
+	{
+		// Stats for completed phases have been getting logged as they
+		// complete.  This will give us stats for any timers that
+		// haven't finished as of the metric's being sent.
+		
+		if (force_send)
+		{
+			LLVOAvatar::logPendingPhasesAllAvatars();
+		}
+		sendViewerAppearanceChangeMetrics();
+	}
+
+	return false;
+}
+
+void LLVOAvatarSelf::addMetricsTimerRecord(const LLSD& record)
+{
+	mPendingTimerRecords.push_back(record);
+}
+
+bool operator<(const LLSD& a, const LLSD& b)
+{
+	std::ostringstream aout, bout;
+	aout << LLSDNotationStreamer(a);
+	bout << LLSDNotationStreamer(b);
+	std::string astring = aout.str();
+	std::string bstring = bout.str();
+
+	return astring < bstring;
+
+}
+
+// Given a vector of LLSD records, return an LLSD array of bucketed stats for val_field.
+LLSD summarize_by_buckets(std::vector<LLSD> in_records,
+						  std::vector<std::string> by_fields,
+						  std::string val_field)
+{
+	LLSD result = LLSD::emptyArray();
+	std::map<LLSD,LLViewerStats::StatsAccumulator> accum;
+	for (std::vector<LLSD>::iterator in_record_iter = in_records.begin();
+		 in_record_iter != in_records.end(); ++in_record_iter)
+	{
+		LLSD& record = *in_record_iter;
+		LLSD key;
+		for (std::vector<std::string>::iterator field_iter = by_fields.begin();
+			 field_iter != by_fields.end(); ++field_iter)
+		{
+			const std::string& field = *field_iter;
+			key[field] = record[field];
+		}
+		LLViewerStats::StatsAccumulator& stats = accum[key];
+		F32 value = record[val_field].asReal();
+		stats.push(value);
+	}
+	for (std::map<LLSD,LLViewerStats::StatsAccumulator>::iterator accum_it = accum.begin();
+		 accum_it != accum.end(); ++accum_it)
+	{
+		LLSD out_record = accum_it->first;
+		out_record["stats"] = accum_it->second.getData();
+		result.append(out_record);
+	}
+	return result;
+}
+
+void LLVOAvatarSelf::sendViewerAppearanceChangeMetrics()
 {
 	// gAgentAvatarp->stopAllPhases();
 	static volatile bool reporting_started(false);
 	static volatile S32 report_sequence(0);

-	LLSD msg = metricsData();
+	LLSD msg; // = metricsData();
 	msg["message"] = "ViewerAppearanceChangeMetrics";
 	msg["session_id"] = gAgentSessionID;
 	msg["agent_id"] = gAgentID;
 	msg["sequence"] = report_sequence;
 	msg["initial"] = !reporting_started;
 	msg["break"] = false;
+	msg["duration"] = mTimeSinceLastRezMessage.getElapsedTimeF32();
+
+	// Status of our own rezzing.
+	msg["rez_status"] = LLVOAvatar::rezStatusToString(getRezzedStatus());
+
+	// Status of all nearby avs including ourself.
+	msg["nearby"] = LLSD::emptyArray();
+	std::vector<S32> rez_counts;
+	LLVOAvatar::getNearbyRezzedStats(rez_counts);
+	for (S32 rez_stat=0; rez_stat < rez_counts.size(); ++rez_stat)
+	{
+		std::string rez_status_name = LLVOAvatar::rezStatusToString(rez_stat);
+		msg["nearby"][rez_status_name] = rez_counts[rez_stat];
+	}
+
+	//	std::vector<std::string> bucket_fields("timer_name","is_self","grid_x","grid_y","is_using_server_bake");
+	std::vector<std::string> by_fields;
+	by_fields.push_back("timer_name");
+	by_fields.push_back("completed");
+	by_fields.push_back("grid_x");
+	by_fields.push_back("grid_y");
+	by_fields.push_back("is_using_server_bakes");
+	by_fields.push_back("is_self");
+	by_fields.push_back("central_bake_version");
+	LLSD summary = summarize_by_buckets(mPendingTimerRecords, by_fields, std::string("elapsed"));
+	msg["timers"] = summary;
+
+	mPendingTimerRecords.clear();

 	// Update sequence number
 	if (S32_MAX == ++report_sequence)
@ -2504,9 +2719,66 @@ void LLVOAvatarSelf::sendAppearanceChangeMetrics()
 						   new ViewerAppearanceChangeMetricsResponder(report_sequence,
 																	  report_sequence,
 																	  reporting_started));
+		mTimeSinceLastRezMessage.reset();
 	}
 }

+class CheckAgentAppearanceServiceResponder: public LLHTTPClient::Responder
+{
+public:
+	CheckAgentAppearanceServiceResponder()
+	{
+	}
+	
+	virtual ~CheckAgentAppearanceServiceResponder()
+	{
+	}
+
+	/* virtual */ void result(const LLSD& content)
+	{
+		LL_DEBUGS("Avatar") << "status OK" << llendl;
+	}
+
+	// Error
+	/*virtual*/ void error(U32 status, const std::string& reason)
+	{
+		if (isAgentAvatarValid())
+		{
+			LL_DEBUGS("Avatar") << "failed, will rebake" << llendl;
+			forceAppearanceUpdate();
+		}
+	}	
+
+	static void forceAppearanceUpdate()
+	{
+		// Trying to rebake immediately after crossing region boundary
+		// seems to be failure prone; adding a delay factor. Yes, this
+		// fix is ad-hoc and not guaranteed to work in all cases.
+		doAfterInterval(boost::bind(&LLVOAvatarSelf::forceBakeAllTextures,
+									gAgentAvatarp.get(), true), 5.0);
+	}
+};
+
+void LLVOAvatarSelf::checkForUnsupportedServerBakeAppearance()
+{
+	// Need to check only if we have a server baked appearance and are
+	// in a non-baking region.
+	if (!gAgentAvatarp->isUsingServerBakes())
+		return;
+	if (!gAgent.getRegion() || gAgent.getRegion()->getCentralBakeVersion()!=0)
+		return;
+
+	// if baked image service is unknown, need to refresh.
+	if (gSavedSettings.getString("AgentAppearanceServiceURL").empty())
+	{
+		CheckAgentAppearanceServiceResponder::forceAppearanceUpdate();
+	}
+	// query baked image service to check status.
+	std::string image_url = gAgentAvatarp->getImageURL(TEX_HEAD_BAKED,
+													   getTE(TEX_HEAD_BAKED)->getID());
+	LLHTTPClient::head(image_url, new CheckAgentAppearanceServiceResponder);
+}
+
 const LLUUID& LLVOAvatarSelf::grabBakedTexture(EBakedTextureIndex baked_index) const
 {
 	if (canGrabBakedTexture(baked_index))
@ -2600,23 +2872,28 @@ void LLVOAvatarSelf::addLocalTextureStats( ETextureIndex type, LLViewerFetchedTe
 {
 	if (!isIndexLocalTexture(type)) return;

-	if (getLocalTextureID(type, index) != IMG_DEFAULT_AVATAR && imagep->getDiscardLevel() != 0)
+	if (getLocalTextureID(type, index) != IMG_DEFAULT_AVATAR)
 	{
-		F32 desired_pixels;
-		desired_pixels = llmin(mPixelArea, (F32)getTexImageArea());
+		imagep->setNoDelete();
+		if (imagep->getDiscardLevel() != 0)
+		{
+			F32 desired_pixels;
+			desired_pixels = llmin(mPixelArea, (F32)getTexImageArea());

-		if (isUsingLocalAppearance())
-		{
-			imagep->setBoostLevel(getAvatarBoostLevel());
-			imagep->setAdditionalDecodePriority(SELF_ADDITIONAL_PRI) ;
-		}
-		imagep->resetTextureStats();
-		imagep->setMaxVirtualSizeResetInterval(MAX_TEXTURE_VIRTURE_SIZE_RESET_INTERVAL);
-		imagep->addTextureStats( desired_pixels / texel_area_ratio );
-		imagep->forceUpdateBindStats() ;
-		if (imagep->getDiscardLevel() < 0)
-		{
-			mHasGrey = TRUE; // for statistics gathering
+			// DRANO what priority should wearable-based textures have?
+			if (isUsingLocalAppearance())
+			{
+				imagep->setBoostLevel(getAvatarBoostLevel());
+				imagep->setAdditionalDecodePriority(SELF_ADDITIONAL_PRI) ;
+			}
+			imagep->resetTextureStats();
+			imagep->setMaxVirtualSizeResetInterval(MAX_TEXTURE_VIRTURE_SIZE_RESET_INTERVAL);
+			imagep->addTextureStats( desired_pixels / texel_area_ratio );
+			imagep->forceUpdateBindStats() ;
+			if (imagep->getDiscardLevel() < 0)
+			{
+				mHasGrey = TRUE; // for statistics gathering
+			}
 		}
 	}
 	else
@ -2789,6 +3066,8 @@ void LLVOAvatarSelf::outputRezDiagnostics() const
 		if (!layerset_buffer) continue;
 		LL_DEBUGS("Avatar") << layerset_buffer->dumpTextureInfo() << llendl;
 	}
+
+	dumpAllTextures();
 }

 void LLVOAvatarSelf::outputRezTiming(const std::string& msg) const
--- a/indra/newview/llvoavatarself.h
+++ b/indra/newview/llvoavatarself.h
@ -390,6 +390,13 @@ public:
 		LLUUID			mAvatarID;
 		LLAvatarAppearanceDefines::ETextureIndex	mIndex;
 	};
+
+	LLTimer					mTimeSinceLastRezMessage;
+	bool					updateAvatarRezMetrics(bool force_send);
+
+	std::vector<LLSD>		mPendingTimerRecords;
+	void 					addMetricsTimerRecord(const LLSD& record);
+	
 	void 					debugWearablesLoaded() { mDebugTimeWearablesLoaded = mDebugSelfLoadTimer.getElapsedTimeF32(); }
 	void 					debugAvatarVisible() { mDebugTimeAvatarVisible = mDebugSelfLoadTimer.getElapsedTimeF32(); }
 	void 					outputRezDiagnostics() const;
@ -401,10 +408,12 @@ public:
 	BOOL					isAllLocalTextureDataFinal() const;

 	const LLViewerTexLayerSet*	debugGetLayerSet(LLAvatarAppearanceDefines::EBakedTextureIndex index) const { return (LLViewerTexLayerSet*)(mBakedTextureDatas[index].mTexLayerSet); }
+	const std::string		verboseDebugDumpLocalTextureDataInfo(const LLViewerTexLayerSet* layerset) const; // Lists out state of this particular baked texture layer
+	void					dumpAllTextures() const;
 	const std::string		debugDumpLocalTextureDataInfo(const LLViewerTexLayerSet* layerset) const; // Lists out state of this particular baked texture layer
 	const std::string		debugDumpAllLocalTextureDataInfo() const; // Lists out which baked textures are at highest LOD
-	LLSD					metricsData();
-	void					sendAppearanceChangeMetrics(); // send data associated with completing a change.
+	void					sendViewerAppearanceChangeMetrics(); // send data associated with completing a change.
+	void 					checkForUnsupportedServerBakeAppearance();
 private:
 	LLFrameTimer    		mDebugSelfLoadTimer;
 	F32						mDebugTimeWearablesLoaded;
@ -424,8 +433,7 @@ extern LLPointer<LLVOAvatarSelf> gAgentAvatarp;
 BOOL isAgentAvatarValid();

 void selfStartPhase(const std::string& phase_name);
-void selfStopPhase(const std::string& phase_name);
-void selfStopAllPhases();
+void selfStopPhase(const std::string& phase_name, bool err_check = true);
 void selfClearPhases();

 #endif // LL_VO_AVATARSELF_H
--- a/indra/newview/llworldmapview.cpp
+++ b/indra/newview/llworldmapview.cpp
@ -151,8 +151,6 @@ void LLWorldMapView::initClass()
 	sStringsMap["loading"] = LLTrans::getString("texture_loading");
 	
 	sStringsMap["offline"] = LLTrans::getString("worldmap_offline");
-	// Missing translation for agent position
-	sStringsMap["agent_position"] = LLTrans::getString("worldmap_agent_position");
 }

 // static
--- a/indra/newview/skins/default/textures/textures.xml
+++ b/indra/newview/skins/default/textures/textures.xml
@ -806,8 +806,6 @@ with the same filename but different name
  <texture name="icon_for_sale.tga" file_name="icons/Icon_For_Sale.png" />
  <texture name="icon_top_pick.tga" />

- <!-- FS Ansariel: Icons don't exist and only spawn warn messages in log
-  -->
  <texture name="lag_status_critical.tga" />
  <texture name="lag_status_good.tga" />
  <texture name="lag_status_warning.tga" />
--- a/indra/newview/skins/default/xui/en/menu_attachment_other.xml
+++ b/indra/newview/skins/default/xui/en/menu_attachment_other.xml
@ -110,6 +110,14 @@
            <menu_item_call.on_visible
             function="IsGodCustomerService"/>
    </menu_item_call>
+    <menu_item_call
+		 label="Dump XML"
+         name="Dump XML">
+            <menu_item_call.on_click
+             function="Advanced.AppearanceToXML" />
+            <menu_item_call.on_visible
+             function="Advanced.EnableAppearanceToXML"/>
+    </menu_item_call>
    <menu_item_call
 		 label="Dump XML"
         name="Dump XML">
--- a/indra/newview/skins/default/xui/en/menu_avatar_self.xml
+++ b/indra/newview/skins/default/xui/en/menu_avatar_self.xml
@ -283,4 +283,12 @@
            <menu_item_call.on_visible
             function="Advanced.EnableAppearanceToXML"/>
    </menu_item_call>
+    <menu_item_call
+		 label="Dump XML"
+         name="Dump XML">
+            <menu_item_call.on_click
+             function="Advanced.AppearanceToXML" />
+            <menu_item_call.on_visible
+             function="Advanced.EnableAppearanceToXML"/>
+    </menu_item_call>
 </context_menu>
--- a/indra/newview/skins/default/xui/en/menu_viewer.xml
+++ b/indra/newview/skins/default/xui/en/menu_viewer.xml
@ -907,6 +907,17 @@
                 function="RLV.EnableIfNot"
                 parameter="setenv" />
            </menu_item_call>
+            <menu_item_separator/>
+            <menu_item_call
+             label="Estate Time"
+             name="Revert to Region Default">
+                <menu_item_call.on_click
+                 function="World.EnvSettings"
+                 parameter="default" />
+                <menu_item_call.on_enable
+                 function="RLV.EnableIfNot"
+                 parameter="setenv" />
+            </menu_item_call>
        </menu>

 	    <menu
@ -2021,6 +2032,184 @@
    </menu>

    <!-- Advanced Menu -->
+    <menu
+     create_jump_keys="true"
+     label="RLVa"
+     name="RLVa Main"
+     tear_off="true"
+     visible="true">
+      <menu
+       label="Debug"
+       name="Debug"
+       tear_off="true">
+        <menu_item_check
+         label="Show Top-level RLVa Menu"
+         name="Show Top-level RLVa Menu">
+          <menu_item_check.on_check
+           function="CheckControl"
+           parameter="RLVaTopLevelMenu" />
+          <menu_item_check.on_click
+           function="ToggleControl"
+           parameter="RLVaTopLevelMenu" />
+        </menu_item_check>
+      	<menu_item_separator/>
+      	<menu_item_check
+      	 label="Show Debug Messages"
+      	 name="Show Debug Messages">
+          <menu_item_check.on_check
+           function="CheckControl"
+           parameter="RestrainedLoveDebug" />
+          <menu_item_check.on_click
+           function="ToggleControl"
+           parameter="RestrainedLoveDebug" />
+      	</menu_item_check>
+      	<menu_item_check
+      	 label="Hide Unset or Duplicate Messages"
+      	 name="Hide Unset or Duplicate Messages">
+          <menu_item_check.on_check
+           function="CheckControl"
+           parameter="RLVaDebugHideUnsetDuplicate" />
+          <menu_item_check.on_click
+           function="ToggleControl"
+           parameter="RLVaDebugHideUnsetDuplicate" />
+      	</menu_item_check>
+      	<menu_item_check
+      	 label="Show Assertion Failures"
+      	 name="Show Assertion Failures">
+          <menu_item_check.on_check
+           function="CheckControl"
+           parameter="RLVaShowAssertionFailures" />
+          <menu_item_check.on_click
+           function="ToggleControl"
+           parameter="RLVaShowAssertionFailures" />
+      	</menu_item_check>
+      	<menu_item_separator/>
+        <menu_item_check
+         label="Hide Locked Layers"
+         name="Hide Locked Layers">
+          <menu_item_check.on_check
+           function="CheckControl"
+           parameter="RLVaHideLockedLayers" />
+          <menu_item_check.on_click
+           function="ToggleControl"
+           parameter="RLVaHideLockedLayers" />
+        </menu_item_check>
+        <menu_item_check
+         label="Hide Locked Attachments"
+         name="Hide Locked Attachments">
+          <menu_item_check.on_check
+           function="CheckControl"
+           parameter="RLVaHideLockedAttachments" />
+          <menu_item_check.on_click
+           function="ToggleControl"
+           parameter="RLVaHideLockedAttachments" />
+        </menu_item_check>
+        <menu_item_separator/>
+      	<menu_item_check
+      	 label="Enable Legacy Naming"
+      	 name="Enable Legacy Naming">
+          <menu_item_check.on_check
+           function="CheckControl"
+           parameter="RLVaEnableLegacyNaming" />
+          <menu_item_check.on_click
+           function="ToggleControl"
+           parameter="RLVaEnableLegacyNaming" />
+      	</menu_item_check>
+        <menu_item_check
+      	 label="Enable Shared Wear"
+      	 name="Enable Shared Wear">
+          <menu_item_check.on_check
+           function="CheckControl"
+           parameter="RLVaEnableSharedWear" />
+          <menu_item_check.on_click
+           function="ToggleControl"
+           parameter="RLVaEnableSharedWear" />
+        </menu_item_check>
+        <menu_item_check
+      	 label="Rename Shared Items on Wear"
+      	 name="Rename Shared Items on Wear">
+          <menu_item_check.on_check
+           function="CheckControl"
+           parameter="RLVaSharedInvAutoRename" />
+          <menu_item_check.on_click
+           function="ToggleControl"
+           parameter="RLVaSharedInvAutoRename" />
+      	</menu_item_check>
+      	<menu_item_separator/>
+      	<menu_item_check
+      	 label="Locks..."
+      	 name="Locks">
+          <menu_item_check.on_check
+           function="Floater.Visible"
+           parameter="rlv_locks" />
+          <menu_item_check.on_click
+           function="Floater.Toggle"
+           parameter="rlv_locks" />
+      	</menu_item_check>
+      </menu>
+      <menu_item_separator/>
+      <menu_item_check
+       label="Allow OOC Chat"
+       name="Allow OOC Chat">
+      	<menu_item_check.on_check
+      	 function="CheckControl"
+      	 parameter="RestrainedLoveCanOOC" />
+      	<menu_item_check.on_click
+      	 function="ToggleControl"
+      	 parameter="RestrainedLoveCanOOC" />
+      </menu_item_check>
+      <menu_item_check
+       label="Forbid Give to #RLV"
+       name="Forbid Give to #RLV">
+      	<menu_item_check.on_check
+      	 function="CheckControl"
+      	 parameter="RestrainedLoveForbidGiveToRLV" />
+      	<menu_item_check.on_click
+      	 function="ToggleControl"
+      	 parameter="RestrainedLoveForbidGiveToRLV" />
+      </menu_item_check>
+      <menu_item_check
+       label="Show Filtered Chat"
+       name="Show Filtered Chat">
+      	<menu_item_check.on_check
+      	 function="CheckControl"
+      	 parameter="RestrainedLoveShowEllipsis" />
+      	<menu_item_check.on_click
+      	 function="ToggleControl"
+      	 parameter="RestrainedLoveShowEllipsis" />
+      </menu_item_check>
+      <menu_item_check
+       label="Show Name Tags"
+       name="Show Name Tags">
+      	<menu_item_check.on_check
+      	 function="CheckControl"
+      	 parameter="RLVaShowNameTags" />
+      	<menu_item_check.on_click
+      	 function="ToggleControl"
+      	 parameter="RLVaShowNameTags" />
+      </menu_item_check>
+      <menu_item_check
+       label="Wear Replaces Unlocked"
+       name="Wear Replaces Unlocked">
+      	<menu_item_check.on_check
+      	 function="CheckControl"
+      	 parameter="RLVaWearReplaceUnlocked" />
+      	<menu_item_check.on_click
+      	 function="ToggleControl"
+      	 parameter="RLVaWearReplaceUnlocked" />
+      </menu_item_check>
+      <menu_item_separator />
+      <menu_item_check
+       label="Restrictions..."
+       name="Restrictions">
+      	<menu_item_check.on_check
+      	 function="Floater.Visible"
+      	 parameter="rlv_behaviours" />
+      	<menu_item_check.on_click
+      	 function="Floater.Toggle"
+      	 parameter="rlv_behaviours" />
+      </menu_item_check>
+    </menu>
    <menu
     create_jump_keys="true"
     label="Advanced"
--- a/indra/newview/tests/llviewerassetstats_test.cpp
+++ b/indra/newview/tests/llviewerassetstats_test.cpp
@ -35,31 +35,6 @@
 #include "lluuid.h"
 #include "llsdutil.h"
 #include "llregionhandle.h"
-#include "../llvoavatar.h"
-
-void LLVOAvatar::getNearbyRezzedStats(std::vector<S32>& counts)
-{
-	counts.resize(3);
-	counts[0] = 0;
-	counts[1] = 0;
-	counts[2] = 1;
-}
-
-// static
-std::string LLVOAvatar::rezStatusToString(S32 rez_status)
-{
-	if (rez_status==0) return "cloud";
-	if (rez_status==1) return "gray";
-	if (rez_status==2) return "textured";
-	return "unknown";
-}
-
-// static
-LLViewerStats::StatsAccumulator& LLViewerStats::PhaseMap::getPhaseStats(const std::string& phase_name)
-{
-	static LLViewerStats::StatsAccumulator junk;
-	return junk;
-}

 static const char * all_keys[] = 
 {
@ -123,31 +98,35 @@ is_empty_map(const LLSD & sd)
 {
 	return sd.isMap() && 0 == sd.size();
 }
+#endif

+#if 0
 static bool
 is_single_key_map(const LLSD & sd, const std::string & key)
 {
 	return sd.isMap() && 1 == sd.size() && sd.has(key);
 }
+#endif

 static bool
 is_double_key_map(const LLSD & sd, const std::string & key1, const std::string & key2)
 {
 	return sd.isMap() && 2 == sd.size() && sd.has(key1) && sd.has(key2);
 }
-#endif

+#if 0
 static bool
 is_triple_key_map(const LLSD & sd, const std::string & key1, const std::string & key2, const std::string& key3)
 {
 	return sd.isMap() && 3 == sd.size() && sd.has(key1) && sd.has(key2) && sd.has(key3);
 }
+#endif


 static bool
 is_no_stats_map(const LLSD & sd)
 {
-	return is_triple_key_map(sd, "duration", "regions", "avatar");
+	return is_double_key_map(sd, "duration", "regions");
 }

 static bool
@ -258,7 +237,7 @@ namespace tut
 		// Once the region is set, we will get a response even with no data collection
 		it->setRegion(region1_handle);
 		sd_full = it->asLLSD(false);
-		ensure("Correct single-key LLSD map root", is_triple_key_map(sd_full, "duration", "regions", "avatar"));
+		ensure("Correct single-key LLSD map root", is_double_key_map(sd_full, "duration", "regions"));
 		ensure("Correct single-slot LLSD array regions", is_single_slot_array(sd_full["regions"], region1_handle));
 		
 		LLSD sd = sd_full["regions"][0];
@ -299,7 +278,7 @@ namespace tut
 		it->setRegion(region1_handle);
 		
 		LLSD sd = it->asLLSD(false);
-		ensure("Correct single-key LLSD map root", is_triple_key_map(sd, "regions", "duration", "avatar"));
+		ensure("Correct single-key LLSD map root", is_double_key_map(sd, "regions", "duration"));
 		ensure("Correct single-slot LLSD array regions", is_single_slot_array(sd["regions"], region1_handle));
 		sd = sd[0];
 		
@ -324,7 +303,7 @@ namespace tut
 		LLViewerAssetStatsFF::record_dequeue_main(LLViewerAssetType::AT_BODYPART, false, false);

 		LLSD sd = gViewerAssetStatsMain->asLLSD(false);
-		ensure("Correct single-key LLSD map root", is_triple_key_map(sd, "regions", "duration", "avatar"));
+		ensure("Correct single-key LLSD map root", is_double_key_map(sd, "regions", "duration"));
 		ensure("Correct single-slot LLSD array regions", is_single_slot_array(sd["regions"], region1_handle));
 		sd = sd["regions"][0];
 		
@ -364,7 +343,7 @@ namespace tut
 		LLSD sd = gViewerAssetStatsThread1->asLLSD(false);
 		ensure("Other collector is empty", is_no_stats_map(sd));
 		sd = gViewerAssetStatsMain->asLLSD(false);
-		ensure("Correct single-key LLSD map root", is_triple_key_map(sd, "regions", "duration", "avatar"));
+		ensure("Correct single-key LLSD map root", is_double_key_map(sd, "regions", "duration"));
 		ensure("Correct single-slot LLSD array regions", is_single_slot_array(sd["regions"], region1_handle));
 		sd = sd["regions"][0];
 		
@ -414,7 +393,7 @@ namespace tut

 		// std::cout << sd << std::endl;
 		
-		ensure("Correct double-key LLSD map root", is_triple_key_map(sd, "duration", "regions", "avatar"));
+		ensure("Correct double-key LLSD map root", is_double_key_map(sd, "duration", "regions"));
 		ensure("Correct double-slot LLSD array regions", is_double_slot_array(sd["regions"], region1_handle, region2_handle));
 		LLSD sd1 = get_region(sd, region1_handle);
 		LLSD sd2 = get_region(sd, region2_handle);
@ -437,7 +416,7 @@ namespace tut
 		// Reset leaves current region in place
 		gViewerAssetStatsMain->reset();
 		sd = gViewerAssetStatsMain->asLLSD(false);
-		ensure("Correct single-key LLSD map root", is_triple_key_map(sd, "regions", "duration", "avatar"));
+		ensure("Correct single-key LLSD map root", is_double_key_map(sd, "regions", "duration"));
 		ensure("Correct single-slot LLSD array regions (p2)", is_single_slot_array(sd["regions"], region2_handle));
 		sd2 = sd["regions"][0];
 		
@ -486,7 +465,7 @@ namespace tut

 		LLSD sd = gViewerAssetStatsMain->asLLSD(false);

-		ensure("Correct double-key LLSD map root", is_triple_key_map(sd, "duration", "regions", "avatar"));
+		ensure("Correct double-key LLSD map root", is_double_key_map(sd, "duration", "regions"));
 		ensure("Correct double-slot LLSD array regions", is_double_slot_array(sd["regions"], region1_handle, region2_handle));
 		LLSD sd1 = get_region(sd, region1_handle);
 		LLSD sd2 = get_region(sd, region2_handle);
@ -509,7 +488,7 @@ namespace tut
 		// Reset leaves current region in place
 		gViewerAssetStatsMain->reset();
 		sd = gViewerAssetStatsMain->asLLSD(false);
-		ensure("Correct single-key LLSD map root", is_triple_key_map(sd, "duration", "regions", "avatar"));
+		ensure("Correct single-key LLSD map root", is_double_key_map(sd, "duration", "regions"));
 		ensure("Correct single-slot LLSD array regions (p2)", is_single_slot_array(sd["regions"], region2_handle));
 		sd2 = get_region(sd, region2_handle);
 		ensure("Region2 is present in results", sd2.isMap());
@ -555,7 +534,7 @@ namespace tut
 		LLSD sd = gViewerAssetStatsThread1->asLLSD(false);
 		ensure("Other collector is empty", is_no_stats_map(sd));
 		sd = gViewerAssetStatsMain->asLLSD(false);
-		ensure("Correct single-key LLSD map root", is_triple_key_map(sd, "regions", "duration", "avatar"));
+		ensure("Correct single-key LLSD map root", is_double_key_map(sd, "regions", "duration"));
 		ensure("Correct single-slot LLSD array regions", is_single_slot_array(sd["regions"], region1_handle));
 		sd = get_region(sd, region1_handle);
 		ensure("Region1 is present in results", sd.isMap());