From bd6b6acf223ebeec5ada8059422473227396f6a6 Mon Sep 17 00:00:00 2001
From: Andrey Lihatskiy <alihatskiy@productengine.com>
Date: Mon, 22 Jul 2024 18:47:41 +0300
Subject: [PATCH 01/30] Update expired cert in integration test

see fe8c976 for more info
---
 .../newview/tests/llsechandler_basic_test.cpp | 670 +++++++++---------
 1 file changed, 345 insertions(+), 325 deletions(-)

diff --git a/indra/newview/tests/llsechandler_basic_test.cpp b/indra/newview/tests/llsechandler_basic_test.cpp
index f6ed745e96..f4ee15319e 100644
--- a/indra/newview/tests/llsechandler_basic_test.cpp
+++ b/indra/newview/tests/llsechandler_basic_test.cpp
@@ -232,381 +232,402 @@ namespace tut
         "Certificate:\n"
         "    Data:\n"
         "        Version: 3 (0x2)\n"
-        "        Serial Number:\n"
-        "            82:2f:8f:eb:8d:06:24:b0\n"
+        "        Serial Number: ef:54:d8:f7:da:18:e8:19\n"
         "    Signature Algorithm: sha256WithRSAEncryption\n"
         "        Issuer: C=US, ST=California, L=San Francisco, O=Linden Lab, OU=Second Life Engineering, CN=Integration Test Root CA/emailAddress=noreply@lindenlab.com\n"
         "        Validity\n"
-        "            Not Before: May 22 22:19:45 2018 GMT\n"
-        "            Not After : May 17 22:19:45 2038 GMT\n"
+        "            Not Before: Jul 23 11:46:26 2024 GMT\n"
+        "            Not After : Jul 21 11:46:26 2034 GMT\n"
         "        Subject: C=US, ST=California, L=San Francisco, O=Linden Lab, OU=Second Life Engineering, CN=Integration Test Root CA/emailAddress=noreply@lindenlab.com\n"
         "        Subject Public Key Info:\n"
         "            Public Key Algorithm: rsaEncryption\n"
         "                Public-Key: (4096 bit)\n"
         "                Modulus:\n"
-        "                    00:bd:e0:79:dd:3b:a6:ac:87:d0:39:f0:58:c7:a4:\n"
-        "                    42:42:f6:5f:93:b0:36:04:b5:e2:d5:f7:2a:c0:6c:\n"
-        "                    a0:13:d2:1e:02:81:57:02:50:4c:57:b7:ef:27:9e:\n"
-        "                    f6:f1:f1:30:30:72:1e:57:34:e5:3f:82:3c:21:c4:\n"
-        "                    66:d2:73:63:6c:91:e6:dd:49:9e:9c:b1:34:6a:81:\n"
-        "                    45:a1:6e:c4:50:28:f2:d8:e3:fe:80:2f:83:aa:28:\n"
-        "                    91:b4:8c:57:c9:f1:16:d9:0c:87:3c:25:80:a0:81:\n"
-        "                    8d:71:f2:96:e2:16:f1:97:c4:b0:d8:53:bb:13:6c:\n"
-        "                    73:54:2f:29:94:85:cf:86:6e:75:71:ad:39:e3:fc:\n"
-        "                    39:12:53:93:1c:ce:39:e0:33:da:49:b7:3d:af:b0:\n"
-        "                    37:ce:77:09:03:27:32:70:c0:9c:7f:9c:89:ce:90:\n"
-        "                    45:b0:7d:94:8b:ff:13:27:ba:88:7f:ae:c4:aa:73:\n"
-        "                    d5:47:b8:87:69:89:80:0c:c1:22:18:78:c2:0d:47:\n"
-        "                    d9:10:ff:80:79:0d:46:71:ec:d9:ba:c9:f3:77:fd:\n"
-        "                    92:6d:1f:0f:d9:54:18:6d:f6:72:24:5c:5c:3d:43:\n"
-        "                    49:35:3e:1c:28:de:7e:44:dc:29:c3:9f:62:04:46:\n"
-        "                    aa:c4:e6:69:6a:15:f8:e3:74:1c:14:e9:f4:97:7c:\n"
-        "                    30:6c:d4:28:fc:2a:0e:1d:6d:39:2e:1d:f9:17:43:\n"
-        "                    35:5d:23:e7:ba:e3:a8:e9:97:6b:3c:3e:23:ef:d8:\n"
-        "                    bc:fb:7a:57:37:39:93:59:03:fc:78:ca:b1:31:ef:\n"
-        "                    26:19:ed:56:e1:63:c3:ad:99:80:5b:47:b5:03:35:\n"
-        "                    5f:fe:6a:a6:21:63:ec:50:fb:4e:c9:f9:ae:a5:66:\n"
-        "                    d0:55:33:8d:e6:c5:50:5a:c6:8f:5c:34:45:a7:72:\n"
-        "                    da:50:f6:66:4c:19:f5:d1:e4:fb:11:8b:a1:b5:4e:\n"
-        "                    09:43:81:3d:39:28:86:3b:fe:07:28:97:02:b5:3a:\n"
-        "                    07:5f:4a:20:80:1a:7d:a4:8c:f7:6c:f6:c5:9b:f6:\n"
-        "                    61:e5:c7:b0:c3:d5:58:38:7b:bb:47:1e:34:d6:16:\n"
-        "                    55:c5:d2:6c:b0:93:77:b1:90:69:06:b1:53:cb:1b:\n"
-        "                    84:71:cf:b8:87:1b:1e:44:35:b4:2b:bb:04:59:58:\n"
-        "                    0b:e8:93:d8:ae:21:9b:b1:1c:89:30:ae:11:80:77:\n"
-        "                    cc:16:f3:d6:35:ed:a1:b3:70:b3:4f:cd:a1:56:99:\n"
-        "                    ee:0e:c0:00:a4:09:70:c3:5b:0b:be:a1:07:18:dd:\n"
-        "                    c6:f4:6d:8b:58:bc:f9:bb:4b:01:2c:f6:cc:2c:9b:\n"
-        "                    87:0e:b1:4f:9c:10:be:fc:45:e2:a4:ec:7e:fc:ff:\n"
-        "                    45:b8:53\n"
+        "                    00:c6:cc:07:f4:0b:17:06:4d:a6:30:b4:c7:02:6b:\n"
+        "                    9d:a4:47:a6:09:0e:60:1a:32:d4:6b:42:88:ee:c5:\n"
+        "                    b9:e9:fb:b5:0b:60:dc:a2:45:92:a5:bb:88:12:fc:\n"
+        "                    42:1a:80:32:79:16:62:7a:97:af:84:28:53:3c:c1:\n"
+        "                    f2:68:c0:4e:45:e4:0a:63:f9:34:1d:a2:8b:cc:70:\n"
+        "                    df:c6:65:c0:ba:31:32:d2:9d:0c:c8:ce:dc:11:12:\n"
+        "                    a4:11:fa:d3:c8:56:e2:31:8a:e3:fb:91:40:da:25:\n"
+        "                    55:d1:f2:75:9b:4d:fa:b8:1f:b5:6d:9b:e1:fe:5d:\n"
+        "                    e8:c4:02:79:14:ef:7d:5a:b3:3a:1e:b6:d0:60:2c:\n"
+        "                    90:dc:22:e2:c5:ae:85:1f:b4:9d:7a:20:f8:af:63:\n"
+        "                    56:25:1a:64:f3:9c:3f:9a:cf:68:08:0a:37:db:d0:\n"
+        "                    a3:65:26:db:80:82:ff:e0:1b:51:c8:ee:f6:ad:c2:\n"
+        "                    b4:f2:ab:d2:e8:85:86:77:28:d0:63:4a:71:78:41:\n"
+        "                    e3:8c:7f:71:51:31:af:24:3f:fa:8d:d0:d8:0b:e2:\n"
+        "                    7e:79:33:8a:bb:d2:00:9e:2e:c8:cd:d5:50:92:b8:\n"
+        "                    5c:5a:0b:99:ef:05:39:67:da:be:70:36:51:37:37:\n"
+        "                    20:6f:84:ab:29:11:00:7b:38:32:ba:0b:bc:34:a6:\n"
+        "                    b5:c6:a7:f0:c0:25:2d:38:0b:72:40:ab:cf:e6:ff:\n"
+        "                    97:75:ff:e2:a9:3c:2a:57:ce:e4:52:20:8c:de:fe:\n"
+        "                    68:ce:54:85:37:ba:b3:7f:2e:53:58:ea:9b:ac:79:\n"
+        "                    6b:16:65:b8:11:88:5a:46:eb:9e:9e:80:3c:89:91:\n"
+        "                    35:e0:c5:33:45:c8:86:4d:25:51:39:b1:72:97:2b:\n"
+        "                    b3:c8:c9:e8:11:cd:32:41:c8:c1:56:22:7e:33:81:\n"
+        "                    85:61:ab:da:9e:6e:5f:24:1c:0f:9b:fa:da:9d:86:\n"
+        "                    1a:66:f6:32:2a:10:80:ea:72:7a:4a:ef:c0:f2:7c:\n"
+        "                    43:02:e6:70:19:6a:e1:02:0a:00:80:51:1c:a3:03:\n"
+        "                    8b:6d:89:9f:91:37:90:d6:d8:9c:73:77:06:9e:bc:\n"
+        "                    95:89:66:ee:43:40:a3:ee:43:a3:f6:2d:43:dd:7b:\n"
+        "                    f0:2f:0b:12:37:49:b7:81:5a:e2:54:6d:71:88:ff:\n"
+        "                    fe:7e:41:25:35:4c:b4:b9:62:65:dd:9f:1f:7a:06:\n"
+        "                    6e:2b:20:58:78:da:08:66:a8:f1:89:de:8f:7f:5c:\n"
+        "                    5e:c2:72:33:7f:b6:8e:41:4c:26:f6:4c:d4:0e:11:\n"
+        "                    44:da:c7:14:f7:8b:79:4e:53:29:87:15:b1:12:e9:\n"
+        "                    19:2b:54:33:d6:2e:7f:bd:42:20:be:fc:d7:9c:b4:\n"
+        "                    7a:0a:db\n"
         "                Exponent: 65537 (0x10001)\n"
         "        X509v3 extensions:\n"
-        "            X509v3 Subject Key Identifier: \n"
-        "                8A:22:C6:9C:2E:11:F3:40:0C:CE:82:0C:22:59:FF:F8:7F:D0:B9:13\n"
-        "            X509v3 Authority Key Identifier: \n"
-        "                keyid:8A:22:C6:9C:2E:11:F3:40:0C:CE:82:0C:22:59:FF:F8:7F:D0:B9:13\n"
+        "            X509v3 Subject Key Identifier:\n"
+        "                4D:7D:AE:0D:A5:5E:22:5A:6A:8F:19:61:54:B3:58:CB:7B:C0:BD:DA\n"
+        "            X509v3 Authority Key Identifier:\n"
+        "                keyid:4D:7D:AE:0D:A5:5E:22:5A:6A:8F:19:61:54:B3:58:CB:7B:C0:BD:DA\n"
         "\n"
-        "            X509v3 Basic Constraints: critical\n"
+        "            X509v3 Basic Constraints:\n"
         "                CA:TRUE\n"
-        "            X509v3 Key Usage: critical\n"
-        "                Digital Signature, Certificate Sign, CRL Sign\n"
         "    Signature Algorithm: sha256WithRSAEncryption\n"
-        "         b3:cb:33:eb:0e:02:64:f4:55:9a:3d:03:9a:cf:6a:4c:18:43:\n"
-        "         f7:42:cb:65:dc:61:52:e5:9f:2f:42:97:3c:93:16:22:d4:af:\n"
-        "         ae:b2:0f:c3:9b:ef:e0:cc:ee:b6:b1:69:a3:d8:da:26:c3:ad:\n"
-        "         3b:c5:64:dc:9f:d4:c2:53:4b:91:6d:c4:92:09:0b:ac:f0:99:\n"
-        "         be:6f:b9:3c:03:4a:6d:9f:01:5d:ec:5a:9a:f3:a7:e5:3b:2c:\n"
-        "         99:57:7d:7e:25:15:68:20:12:30:96:16:86:f5:db:74:90:60:\n"
-        "         fe:8b:df:99:f6:f7:62:49:9f:bc:8d:45:23:0a:c8:73:b8:79:\n"
-        "         80:3c:b9:e5:72:85:4b:b3:81:66:74:a2:72:92:4c:44:fd:7b:\n"
-        "         46:2e:21:a2:a9:81:a2:f3:26:4d:e3:89:7d:78:b0:c6:6f:b5:\n"
-        "         87:cb:ee:25:ed:27:1f:75:13:fa:6d:e9:37:73:ad:07:bb:af:\n"
-        "         d3:6c:87:ea:02:01:70:bd:53:aa:ce:39:2c:d4:66:39:33:aa:\n"
-        "         d1:9c:ee:67:e3:a9:45:d2:7b:2e:54:09:af:70:5f:3f:5a:67:\n"
-        "         2e:6c:72:ef:e0:9d:92:28:4a:df:ba:0b:b7:23:ca:5b:04:11:\n"
-        "         45:d1:51:e9:ea:c9:ec:54:fa:34:46:ae:fc:dc:6c:f8:1e:2c:\n"
-        "         9e:f4:71:51:8d:b5:a1:26:9a:13:30:be:1e:41:25:59:58:05:\n"
-        "         2c:64:c8:f9:5e:38:ae:dc:93:b0:8a:d6:38:74:02:cb:ce:ce:\n"
-        "         95:31:76:f6:7c:bf:a4:a1:8e:27:fd:ca:74:82:d1:e1:4d:b6:\n"
-        "         48:51:fa:c5:17:59:22:a3:84:be:82:c8:83:ec:61:a0:f4:ee:\n"
-        "         2c:e3:a3:ea:e5:51:c9:d3:4f:db:85:bd:ba:7a:52:14:b6:03:\n"
-        "         ed:43:17:d8:d7:1c:22:5e:c9:56:d9:d6:81:96:11:e3:5e:01:\n"
-        "         40:91:30:09:da:a3:5f:d3:27:60:e5:9d:6c:da:d0:f0:39:01:\n"
-        "         23:4a:a6:15:7a:4a:82:eb:ec:72:4a:1d:36:dc:6f:83:c4:85:\n"
-        "         84:b5:8d:cd:09:e5:12:63:f3:21:56:c8:64:6b:db:b8:cf:d4:\n"
-        "         df:ca:a8:24:8e:df:8d:63:a5:96:84:bf:ff:8b:7e:46:7a:f0:\n"
-        "         c7:73:7c:70:8a:f5:17:d0:ac:c8:89:1e:d7:89:42:0f:4d:66:\n"
-        "         c4:d8:bb:36:a8:ae:ca:e1:cf:e2:88:f6:cf:b0:44:4a:5f:81:\n"
-        "         50:4b:d6:28:81:cd:6c:f0:ec:e6:09:08:f2:59:91:a2:69:ac:\n"
-        "         c7:81:fa:ab:61:3e:db:6f:f6:7f:db:1a:9e:b9:5d:cc:cc:33:\n"
-        "         fa:95:c6:f7:8d:4b:30:f3\n"
+        "         5b:40:71:96:c8:d1:57:3f:fc:f2:3c:75:fb:c9:a6:a7:63:8a:\n"
+        "         22:23:96:0f:40:77:77:e2:7f:76:fc:5f:7b:1c:bd:ea:ca:f0:\n"
+        "         be:1a:fd:59:e6:0e:00:d1:78:44:01:28:f4:01:68:67:78:cf:\n"
+        "         78:43:36:ac:b2:5c:13:0e:2a:94:59:88:9e:64:46:42:0a:9b:\n"
+        "         be:7d:2d:10:11:fe:8b:64:01:fb:00:c5:2e:47:63:c0:93:3a:\n"
+        "         4a:f8:6c:fc:a9:16:58:ab:bc:7b:6b:20:31:9d:d7:d8:84:01:\n"
+        "         cc:ce:52:7f:a1:18:2f:5c:c9:59:58:9a:98:b9:ef:54:d7:a0:\n"
+        "         56:79:28:ba:ad:f5:e5:fd:7e:d8:d6:be:dd:25:76:6f:fa:8a:\n"
+        "         07:f6:8e:0f:83:43:19:ee:96:c4:c9:54:df:19:5a:4c:ae:25:\n"
+        "         57:a2:5d:d5:e8:0a:66:d8:19:e9:c4:44:ba:6a:3b:b3:86:ae:\n"
+        "         44:c0:7c:6e:e5:a0:6c:45:bb:7f:34:94:e9:d3:d4:f4:04:0b:\n"
+        "         eb:fc:9a:fa:67:d4:e5:83:5e:08:09:9c:70:a9:d3:0d:8a:08:\n"
+        "         ed:3c:04:33:4f:ac:02:d9:5c:99:62:12:fc:0e:8d:55:8a:ce:\n"
+        "         ca:28:5a:1a:9e:c9:59:8e:f0:f5:19:c7:30:1e:59:1f:3c:77:\n"
+        "         6d:fc:a2:31:ec:bf:83:fd:14:26:91:68:88:05:4c:87:82:e0:\n"
+        "         33:f4:ee:d8:56:97:23:3a:00:9b:e7:a2:10:c2:83:28:c6:c0:\n"
+        "         c1:92:49:95:c1:d3:e1:43:e8:8f:0c:d0:ae:e3:50:17:1a:8d:\n"
+        "         0f:4a:60:71:76:8e:9e:fb:15:76:cd:cd:69:2c:59:24:69:d2:\n"
+        "         0f:f2:d5:0e:96:95:2b:2e:d7:81:ed:b3:7b:6f:ce:60:32:b5:\n"
+        "         f0:f6:74:ea:27:3a:ee:2c:96:7b:e0:06:6c:33:25:c4:60:da:\n"
+        "         76:de:c4:a1:22:b6:b1:63:57:10:3c:62:60:98:47:39:9e:38:\n"
+        "         ce:c7:ef:75:75:19:d3:26:2a:cf:46:e3:b0:72:38:49:ee:c3:\n"
+        "         4e:52:97:e5:e5:b8:bc:b1:45:56:98:54:0a:63:c8:87:ff:a0:\n"
+        "         cb:28:12:5c:8f:a2:6e:a7:f9:50:98:2d:a5:26:08:df:16:29:\n"
+        "         19:63:7f:6c:b4:41:20:f7:5d:ef:6a:90:fd:1a:08:1c:c2:4c:\n"
+        "         3e:77:ea:e0:df:c0:dd:aa:a2:36:e7:e8:be:98:39:0a:68:59:\n"
+        "         8e:a0:71:2f:7c:92:ab:e0:c4:c1:c2:eb:89:b6:34:ce:44:ab:\n"
+        "         f9:f6:a4:c8:7b:ad:a8:bc:c9:04:7c:d5:4c:a4:d2:8b:54:23:\n"
+        "         89:68:86:4e:07:36:d9:bc\n"
         "-----BEGIN CERTIFICATE-----\n"
-        "MIIGXDCCBESgAwIBAgIJAIIvj+uNBiSwMA0GCSqGSIb3DQEBCwUAMIG6MQswCQYD\n"
+        "MIIGSTCCBDGgAwIBAgIJAO9U2PfaGOgZMA0GCSqGSIb3DQEBCwUAMIG6MQswCQYD\n"
         "VQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNU2FuIEZyYW5j\n"
         "aXNjbzETMBEGA1UECgwKTGluZGVuIExhYjEgMB4GA1UECwwXU2Vjb25kIExpZmUg\n"
         "RW5naW5lZXJpbmcxITAfBgNVBAMMGEludGVncmF0aW9uIFRlc3QgUm9vdCBDQTEk\n"
-        "MCIGCSqGSIb3DQEJARYVbm9yZXBseUBsaW5kZW5sYWIuY29tMB4XDTE4MDUyMjIy\n"
-        "MTk0NVoXDTM4MDUxNzIyMTk0NVowgboxCzAJBgNVBAYTAlVTMRMwEQYDVQQIDApD\n"
+        "MCIGCSqGSIb3DQEJARYVbm9yZXBseUBsaW5kZW5sYWIuY29tMB4XDTI0MDcyMzEx\n"
+        "NDYyNloXDTM0MDcyMTExNDYyNlowgboxCzAJBgNVBAYTAlVTMRMwEQYDVQQIDApD\n"
         "YWxpZm9ybmlhMRYwFAYDVQQHDA1TYW4gRnJhbmNpc2NvMRMwEQYDVQQKDApMaW5k\n"
         "ZW4gTGFiMSAwHgYDVQQLDBdTZWNvbmQgTGlmZSBFbmdpbmVlcmluZzEhMB8GA1UE\n"
         "AwwYSW50ZWdyYXRpb24gVGVzdCBSb290IENBMSQwIgYJKoZIhvcNAQkBFhVub3Jl\n"
         "cGx5QGxpbmRlbmxhYi5jb20wggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC\n"
-        "AQC94HndO6ash9A58FjHpEJC9l+TsDYEteLV9yrAbKAT0h4CgVcCUExXt+8nnvbx\n"
-        "8TAwch5XNOU/gjwhxGbSc2NskebdSZ6csTRqgUWhbsRQKPLY4/6AL4OqKJG0jFfJ\n"
-        "8RbZDIc8JYCggY1x8pbiFvGXxLDYU7sTbHNULymUhc+GbnVxrTnj/DkSU5Mczjng\n"
-        "M9pJtz2vsDfOdwkDJzJwwJx/nInOkEWwfZSL/xMnuoh/rsSqc9VHuIdpiYAMwSIY\n"
-        "eMINR9kQ/4B5DUZx7Nm6yfN3/ZJtHw/ZVBht9nIkXFw9Q0k1Phwo3n5E3CnDn2IE\n"
-        "RqrE5mlqFfjjdBwU6fSXfDBs1Cj8Kg4dbTkuHfkXQzVdI+e646jpl2s8PiPv2Lz7\n"
-        "elc3OZNZA/x4yrEx7yYZ7VbhY8OtmYBbR7UDNV/+aqYhY+xQ+07J+a6lZtBVM43m\n"
-        "xVBaxo9cNEWnctpQ9mZMGfXR5PsRi6G1TglDgT05KIY7/gcolwK1OgdfSiCAGn2k\n"
-        "jPds9sWb9mHlx7DD1Vg4e7tHHjTWFlXF0mywk3exkGkGsVPLG4Rxz7iHGx5ENbQr\n"
-        "uwRZWAvok9iuIZuxHIkwrhGAd8wW89Y17aGzcLNPzaFWme4OwACkCXDDWwu+oQcY\n"
-        "3cb0bYtYvPm7SwEs9swsm4cOsU+cEL78ReKk7H78/0W4UwIDAQABo2MwYTAdBgNV\n"
-        "HQ4EFgQUiiLGnC4R80AMzoIMIln/+H/QuRMwHwYDVR0jBBgwFoAUiiLGnC4R80AM\n"
-        "zoIMIln/+H/QuRMwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYwDQYJ\n"
-        "KoZIhvcNAQELBQADggIBALPLM+sOAmT0VZo9A5rPakwYQ/dCy2XcYVLlny9ClzyT\n"
-        "FiLUr66yD8Ob7+DM7raxaaPY2ibDrTvFZNyf1MJTS5FtxJIJC6zwmb5vuTwDSm2f\n"
-        "AV3sWprzp+U7LJlXfX4lFWggEjCWFob123SQYP6L35n292JJn7yNRSMKyHO4eYA8\n"
-        "ueVyhUuzgWZ0onKSTET9e0YuIaKpgaLzJk3jiX14sMZvtYfL7iXtJx91E/pt6Tdz\n"
-        "rQe7r9Nsh+oCAXC9U6rOOSzUZjkzqtGc7mfjqUXSey5UCa9wXz9aZy5scu/gnZIo\n"
-        "St+6C7cjylsEEUXRUenqyexU+jRGrvzcbPgeLJ70cVGNtaEmmhMwvh5BJVlYBSxk\n"
-        "yPleOK7ck7CK1jh0AsvOzpUxdvZ8v6Shjif9ynSC0eFNtkhR+sUXWSKjhL6CyIPs\n"
-        "YaD07izjo+rlUcnTT9uFvbp6UhS2A+1DF9jXHCJeyVbZ1oGWEeNeAUCRMAnao1/T\n"
-        "J2DlnWza0PA5ASNKphV6SoLr7HJKHTbcb4PEhYS1jc0J5RJj8yFWyGRr27jP1N/K\n"
-        "qCSO341jpZaEv/+LfkZ68MdzfHCK9RfQrMiJHteJQg9NZsTYuzaorsrhz+KI9s+w\n"
-        "REpfgVBL1iiBzWzw7OYJCPJZkaJprMeB+qthPttv9n/bGp65XczMM/qVxveNSzDz\n"
+        "AQDGzAf0CxcGTaYwtMcCa52kR6YJDmAaMtRrQojuxbnp+7ULYNyiRZKlu4gS/EIa\n"
+        "gDJ5FmJ6l6+EKFM8wfJowE5F5Apj+TQdoovMcN/GZcC6MTLSnQzIztwREqQR+tPI\n"
+        "VuIxiuP7kUDaJVXR8nWbTfq4H7Vtm+H+XejEAnkU731aszoettBgLJDcIuLFroUf\n"
+        "tJ16IPivY1YlGmTznD+az2gICjfb0KNlJtuAgv/gG1HI7vatwrTyq9LohYZ3KNBj\n"
+        "SnF4QeOMf3FRMa8kP/qN0NgL4n55M4q70gCeLsjN1VCSuFxaC5nvBTln2r5wNlE3\n"
+        "NyBvhKspEQB7ODK6C7w0prXGp/DAJS04C3JAq8/m/5d1/+KpPCpXzuRSIIze/mjO\n"
+        "VIU3urN/LlNY6puseWsWZbgRiFpG656egDyJkTXgxTNFyIZNJVE5sXKXK7PIyegR\n"
+        "zTJByMFWIn4zgYVhq9qebl8kHA+b+tqdhhpm9jIqEIDqcnpK78DyfEMC5nAZauEC\n"
+        "CgCAURyjA4ttiZ+RN5DW2JxzdwaevJWJZu5DQKPuQ6P2LUPde/AvCxI3SbeBWuJU\n"
+        "bXGI//5+QSU1TLS5YmXdnx96Bm4rIFh42ghmqPGJ3o9/XF7CcjN/to5BTCb2TNQO\n"
+        "EUTaxxT3i3lOUymHFbES6RkrVDPWLn+9QiC+/NectHoK2wIDAQABo1AwTjAdBgNV\n"
+        "HQ4EFgQUTX2uDaVeIlpqjxlhVLNYy3vAvdowHwYDVR0jBBgwFoAUTX2uDaVeIlpq\n"
+        "jxlhVLNYy3vAvdowDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAgEAW0Bx\n"
+        "lsjRVz/88jx1+8mmp2OKIiOWD0B3d+J/dvxfexy96srwvhr9WeYOANF4RAEo9AFo\n"
+        "Z3jPeEM2rLJcEw4qlFmInmRGQgqbvn0tEBH+i2QB+wDFLkdjwJM6Svhs/KkWWKu8\n"
+        "e2sgMZ3X2IQBzM5Sf6EYL1zJWViamLnvVNegVnkouq315f1+2Na+3SV2b/qKB/aO\n"
+        "D4NDGe6WxMlU3xlaTK4lV6Jd1egKZtgZ6cREumo7s4auRMB8buWgbEW7fzSU6dPU\n"
+        "9AQL6/ya+mfU5YNeCAmccKnTDYoI7TwEM0+sAtlcmWIS/A6NVYrOyihaGp7JWY7w\n"
+        "9RnHMB5ZHzx3bfyiMey/g/0UJpFoiAVMh4LgM/Tu2FaXIzoAm+eiEMKDKMbAwZJJ\n"
+        "lcHT4UPojwzQruNQFxqND0pgcXaOnvsVds3NaSxZJGnSD/LVDpaVKy7Xge2ze2/O\n"
+        "YDK18PZ06ic67iyWe+AGbDMlxGDadt7EoSK2sWNXEDxiYJhHOZ44zsfvdXUZ0yYq\n"
+        "z0bjsHI4Se7DTlKX5eW4vLFFVphUCmPIh/+gyygSXI+ibqf5UJgtpSYI3xYpGWN/\n"
+        "bLRBIPdd72qQ/RoIHMJMPnfq4N/A3aqiNufovpg5CmhZjqBxL3ySq+DEwcLribY0\n"
+        "zkSr+fakyHutqLzJBHzVTKTSi1QjiWiGTgc22bw=\n"
         "-----END CERTIFICATE-----\n"
-                                   );
+    );
+
 
     const std::string mPemIntermediateCert(
         "Certificate:\n"
         "    Data:\n"
         "        Version: 3 (0x2)\n"
-        "        Serial Number: 4096 (0x1000)\n"
+        "        Serial Number: 85:bb:4b:66:26:db:9a:c6\n"
         "    Signature Algorithm: sha256WithRSAEncryption\n"
         "        Issuer: C=US, ST=California, L=San Francisco, O=Linden Lab, OU=Second Life Engineering, CN=Integration Test Root CA/emailAddress=noreply@lindenlab.com\n"
         "        Validity\n"
-        "            Not Before: May 22 22:39:08 2018 GMT\n"
-        "            Not After : May 19 22:39:08 2028 GMT\n"
-        "        Subject: C=US, ST=California, O=Linden Lab, OU=Second Life Engineering, CN=Integration Test Intermediate CA/emailAddress=noreply@lindenlab.com\n"
+        "            Not Before: Jul 23 11:46:33 2024 GMT\n"
+        "            Not After : Jul 21 11:46:33 2034 GMT\n"
+        "        Subject: C=US, ST=California, L=San Francisco, O=Linden Lab, OU=Second Life Engineering, CN=Integration Test Intermediate CA/emailAddress=noreply@lindenlab.com\n"
         "        Subject Public Key Info:\n"
         "            Public Key Algorithm: rsaEncryption\n"
         "                Public-Key: (4096 bit)\n"
         "                Modulus:\n"
-        "                    00:ce:a3:70:e2:c4:fb:4b:97:90:a1:30:bb:c1:1b:\n"
-        "                    13:b9:aa:7e:46:17:a3:26:8d:69:3f:5e:73:95:e8:\n"
-        "                    6a:b1:0a:b4:8f:50:65:e3:c6:5c:39:24:34:df:0b:\n"
-        "                    b7:cc:ce:62:0c:36:5a:12:2c:fe:35:4c:e9:1c:ac:\n"
-        "                    80:5e:24:99:d7:aa:bd:be:48:c0:62:64:77:36:88:\n"
-        "                    66:ce:f4:a8:dd:d2:76:24:62:90:55:41:fc:1d:13:\n"
-        "                    4e:a7:4e:57:bc:a8:a4:59:4b:2c:5a:1c:d8:cc:16:\n"
-        "                    de:e8:88:30:c9:95:df:2f:a6:14:28:0f:eb:34:46:\n"
-        "                    12:58:ba:da:0e:e6:de:9c:15:f6:f4:e3:9f:74:aa:\n"
-        "                    70:89:79:8b:e9:5a:7b:18:54:15:94:3a:23:0a:65:\n"
-        "                    78:05:d9:33:90:2a:ce:15:18:0d:52:fc:5c:31:65:\n"
-        "                    20:d0:12:37:8c:11:80:ba:d4:b0:82:73:00:4b:49:\n"
-        "                    be:cb:d6:bc:e7:cd:61:f3:00:98:99:74:5a:37:81:\n"
-        "                    49:96:7e:14:01:1b:86:d2:d0:06:94:40:63:63:46:\n"
-        "                    11:fc:33:5c:bd:3a:5e:d4:e5:44:47:64:50:bd:a6:\n"
-        "                    97:55:70:64:9b:26:cc:de:20:82:90:6a:83:41:9c:\n"
-        "                    6f:71:47:14:be:cb:68:7c:85:be:ef:2e:76:12:19:\n"
-        "                    d3:c9:87:32:b4:ac:60:20:16:28:2d:af:bc:e8:01:\n"
-        "                    c6:7f:fb:d8:11:d5:f4:b7:14:bd:27:08:5b:72:be:\n"
-        "                    09:e0:91:c8:9c:7b:b4:b3:12:ef:32:36:be:b1:b9:\n"
-        "                    a2:b7:e3:69:47:30:76:ba:9c:9b:19:99:4d:53:dd:\n"
-        "                    5c:e8:2c:f1:b2:64:69:cf:15:bd:f8:bb:58:95:73:\n"
-        "                    58:38:95:b4:7a:cf:84:29:a6:c2:db:f0:bd:ef:97:\n"
-        "                    26:d4:99:ac:d7:c7:be:b0:0d:11:f4:26:86:2d:77:\n"
-        "                    42:52:25:d7:56:c7:e3:97:b1:36:5c:97:71:d0:9b:\n"
-        "                    f5:b5:50:8d:f9:ff:fb:10:77:3c:b5:53:6d:a1:43:\n"
-        "                    35:a9:03:32:05:ab:d7:f5:d1:19:bd:5f:92:a3:00:\n"
-        "                    2a:79:37:a4:76:4f:e9:32:0d:e4:86:bb:ea:c3:1a:\n"
-        "                    c5:33:e8:16:d4:a5:d8:e0:e8:bb:c2:f0:22:15:e2:\n"
-        "                    d9:8c:ae:ac:7d:2b:bf:eb:a3:4c:3b:29:1d:94:ac:\n"
-        "                    a3:bb:6d:ba:6d:03:91:03:cf:46:12:c4:66:21:c5:\n"
-        "                    c6:67:d8:11:19:79:01:0e:6e:84:1c:76:6f:11:3d:\n"
-        "                    eb:94:89:c5:6a:26:1f:cd:e0:11:8b:51:ee:99:35:\n"
-        "                    69:e5:7f:0b:77:2a:94:e4:4b:64:b9:83:04:30:05:\n"
-        "                    e4:a2:e3\n"
+        "                    00:be:f7:d2:cb:e4:5c:46:7b:e2:11:22:89:72:da:\n"
+        "                    77:72:ec:05:87:19:f7:77:07:fd:67:d7:af:13:d5:\n"
+        "                    76:12:92:dd:69:4d:22:47:b0:3d:94:8a:6a:95:85:\n"
+        "                    34:b8:78:c3:9d:63:32:b1:4b:0a:b6:0e:05:7b:ab:\n"
+        "                    06:23:fc:0d:21:b5:fc:c6:6a:5a:36:be:6e:fc:c7:\n"
+        "                    47:97:a3:18:2e:33:cd:0e:8a:75:2b:b7:29:e9:68:\n"
+        "                    4a:90:53:45:db:73:ff:b3:e5:c1:d4:6b:dd:3a:b1:\n"
+        "                    ef:53:9f:23:e9:c6:87:ce:67:b9:fb:a4:d5:76:21:\n"
+        "                    03:cb:c5:72:6b:c5:a6:07:55:fb:47:90:e8:92:38:\n"
+        "                    73:14:11:8e:ff:21:b9:35:64:5a:61:c7:fc:1f:e4:\n"
+        "                    4d:47:e5:03:cc:0b:c3:69:66:71:84:0c:18:2f:61:\n"
+        "                    7f:34:dd:f2:91:e3:b7:9d:a8:b8:db:3f:6e:6f:96:\n"
+        "                    fa:34:06:82:04:c8:18:cc:de:8b:7f:26:b5:48:53:\n"
+        "                    fb:fb:15:7b:0e:38:60:fe:da:21:98:8d:73:07:b2:\n"
+        "                    6b:fd:ad:21:59:e7:84:66:e1:04:16:1c:be:13:34:\n"
+        "                    28:43:2c:09:3d:e4:77:2a:a4:ad:6d:f9:26:04:f7:\n"
+        "                    43:73:9b:d9:ea:1a:43:6a:b4:db:88:f8:f9:bd:34:\n"
+        "                    f8:a6:e8:7a:ab:b4:b2:e1:29:47:a6:ba:b8:65:9c:\n"
+        "                    c6:b3:af:13:43:38:ef:2a:05:77:9f:8f:f0:0c:56:\n"
+        "                    21:c2:92:d2:2c:c3:32:50:d1:62:ae:51:fc:99:e6:\n"
+        "                    b8:38:f8:83:1d:8d:40:11:e0:1d:51:5d:3f:fa:55:\n"
+        "                    61:b6:18:09:1e:71:af:95:64:9c:ea:c6:11:64:f0:\n"
+        "                    a8:02:7d:bb:c8:54:2e:57:48:32:7c:51:66:0d:d6:\n"
+        "                    3e:0e:ed:5e:30:a8:a6:47:03:64:5c:89:21:45:90:\n"
+        "                    e1:4c:91:bc:bd:81:6e:73:a9:14:27:e6:0d:6d:38:\n"
+        "                    dc:50:9d:b2:56:66:60:6c:66:b9:5d:bb:8c:96:2d:\n"
+        "                    89:5e:0d:2b:ed:b8:03:31:ce:0a:ff:82:03:f5:b2:\n"
+        "                    3b:e5:27:de:61:d8:8f:bf:a2:6a:64:b0:4a:87:23:\n"
+        "                    40:28:a3:f1:ec:96:50:cd:83:50:2d:78:71:92:f2:\n"
+        "                    88:75:b0:9d:cd:0b:e4:62:a6:a5:63:11:fc:b4:ba:\n"
+        "                    9f:c6:67:40:2c:ad:a4:ef:94:f0:f9:a0:ba:e1:52:\n"
+        "                    2e:27:d9:6b:1d:82:23:ed:3c:0b:0b:d2:bc:14:be:\n"
+        "                    6d:b1:69:ad:3e:25:3a:66:d2:d1:af:9f:88:45:25:\n"
+        "                    6b:6e:be:1f:a0:e7:b2:9f:6d:24:94:0d:f4:c2:75:\n"
+        "                    f9:1f:5d\n"
         "                Exponent: 65537 (0x10001)\n"
         "        X509v3 extensions:\n"
-        "            X509v3 Subject Key Identifier: \n"
-        "                83:21:DE:EC:C0:79:03:6D:1E:83:F3:E5:97:29:D5:5A:C0:96:40:FA\n"
-        "            X509v3 Authority Key Identifier: \n"
-        "                keyid:8A:22:C6:9C:2E:11:F3:40:0C:CE:82:0C:22:59:FF:F8:7F:D0:B9:13\n"
-        "\n"
-        "            X509v3 Basic Constraints: critical\n"
+        "            X509v3 Basic Constraints:\n"
         "                CA:TRUE, pathlen:0\n"
-        "            X509v3 Key Usage: critical\n"
+        "            X509v3 Key Usage:\n"
         "                Digital Signature, Certificate Sign, CRL Sign\n"
+        "            X509v3 Subject Key Identifier:\n"
+        "                56:98:DC:45:25:11:E2:8C:2B:EA:D6:C6:E2:C8:BE:2C:C8:69:FF:FF\n"
+        "            X509v3 Authority Key Identifier:\n"
+        "                keyid:4D:7D:AE:0D:A5:5E:22:5A:6A:8F:19:61:54:B3:58:CB:7B:C0:BD:DA\n"
+        "                DirName:/C=US/ST=California/L=San Francisco/O=Linden Lab/OU=Second Life Engineering/CN=Integration Test Root CA/emailAddress=noreply@lindenlab.com\n"
+        "                serial:EF:54:D8:F7:DA:18:E8:19\n"
         "    Signature Algorithm: sha256WithRSAEncryption\n"
-        "         a3:6c:85:9a:2e:4e:7e:5d:83:63:0f:f5:4f:a9:7d:ec:0e:6f:\n"
-        "         ae:d7:ba:df:64:e0:46:0e:3d:da:18:15:2c:f3:73:ca:81:b1:\n"
-        "         10:d9:53:14:21:7d:72:5c:94:88:a5:9d:ad:ab:45:42:c6:64:\n"
-        "         a9:d9:2e:4e:29:47:2c:b1:95:07:b7:62:48:68:1f:68:13:1c:\n"
-        "         d2:a0:fb:5e:38:24:4a:82:0a:87:c9:93:20:43:7e:e9:f9:79:\n"
-        "         ef:03:a2:bd:9e:24:6b:0a:01:5e:4a:36:c5:7d:7a:fe:d6:aa:\n"
-        "         2f:c2:8c:38:8a:99:3c:b0:6a:e5:60:be:56:d6:eb:60:03:55:\n"
-        "         24:42:a0:1a:fa:91:24:a3:53:15:75:5d:c8:eb:7c:1e:68:5a:\n"
-        "         7e:13:34:e3:85:37:1c:76:3f:77:67:1b:ed:1b:52:17:fc:4a:\n"
-        "         a3:e2:74:84:80:2c:69:fc:dd:7d:26:97:c4:2a:69:7d:9c:dc:\n"
-        "         61:97:70:29:a7:3f:2b:5b:2b:22:51:fd:fe:6a:5d:f9:e7:14:\n"
-        "         48:b7:2d:c8:33:58:fc:f2:5f:27:f7:26:16:be:be:b5:aa:a2:\n"
-        "         64:53:3c:69:e8:b5:61:eb:ab:91:a5:b4:09:9b:f6:98:b8:5c:\n"
-        "         5b:24:2f:93:f5:2b:9c:8c:58:fb:26:3f:67:53:d7:42:64:e8:\n"
-        "         79:77:73:41:4e:e3:02:39:0b:b6:68:97:8b:84:e8:1d:83:a8:\n"
-        "         15:f1:06:46:47:80:42:5e:14:e2:61:8a:76:84:d5:d4:71:7f:\n"
-        "         4e:ff:d9:74:87:ff:32:c5:87:20:0a:d4:59:40:3e:d8:17:ef:\n"
-        "         da:65:e9:0a:51:fe:1e:c3:46:91:d2:ee:e4:23:57:97:87:d4:\n"
-        "         a6:a5:eb:ef:81:6a:d8:8c:d6:1f:8e:b1:18:4c:6b:89:32:55:\n"
-        "         53:68:26:9e:bb:03:be:2c:e9:8b:ff:97:9c:1c:ac:28:c3:9f:\n"
-        "         0b:b7:93:23:24:31:63:e4:19:13:f2:bb:08:71:b7:c5:c5:c4:\n"
-        "         10:ff:dc:fc:33:54:a4:5e:ec:a3:fe:0a:80:ca:9c:bc:95:6f:\n"
-        "         5f:39:91:3b:61:69:16:94:0f:57:4b:fc:4b:b1:be:72:98:5d:\n"
-        "         10:f9:08:a7:d6:e0:e8:3d:5d:54:7d:fa:4b:6a:dd:98:41:ed:\n"
-        "         84:a1:39:67:5c:6c:7f:0c:b0:e1:98:c1:14:ed:fe:1e:e8:05:\n"
-        "         8d:7f:6a:24:cb:1b:05:42:0d:7f:13:ba:ca:b5:91:db:a5:f0:\n"
-        "         40:2b:70:7a:2a:a5:5d:ed:56:0c:f0:c2:72:ee:63:dd:cb:5d:\n"
-        "         76:f6:08:e6:e6:30:ef:3a:b2:16:34:41:a4:e1:30:14:bc:c7:\n"
-        "         f9:23:3a:1a:70:df:b8:cc\n"
+        "         ae:d0:30:ac:31:49:20:86:0b:34:01:58:08:94:68:cc:38:9c:\n"
+        "         f7:13:5c:46:19:33:ed:54:5e:e4:43:f3:59:33:5c:50:d9:89:\n"
+        "         8b:ee:75:67:a8:c7:0e:d1:30:c2:4e:a3:2e:a8:64:2d:6a:a8:\n"
+        "         f4:bd:b1:32:dc:bc:46:48:5d:1a:18:d8:e8:0b:8c:fe:7b:51:\n"
+        "         d9:dd:b9:e3:4b:d1:f9:e0:22:46:dd:37:5b:b2:cb:72:8e:9c:\n"
+        "         4b:da:67:df:fd:ce:86:49:21:31:4e:99:b6:d4:38:0b:14:5d:\n"
+        "         ad:97:ba:8f:e2:08:15:85:73:eb:4a:7d:01:49:af:63:ae:2d:\n"
+        "         e3:9d:0a:d7:11:c2:03:d3:15:21:97:be:3d:d2:ea:ab:cc:93:\n"
+        "         16:98:64:80:72:eb:c2:78:0a:09:69:c4:2b:5d:df:30:7b:be:\n"
+        "         9b:02:34:73:62:9f:95:b1:cf:08:e8:9e:57:a8:37:31:cf:2c:\n"
+        "         8c:18:b1:d5:7a:25:90:d6:b6:76:28:1b:e2:b1:cf:1b:f1:ef:\n"
+        "         dd:2f:d3:07:af:81:e3:5f:fc:5a:e7:3c:a9:37:0d:9c:78:5b:\n"
+        "         58:dc:89:54:70:a4:5b:ff:9f:64:30:a3:85:12:32:69:a5:02:\n"
+        "         73:d9:1d:ff:69:1f:d4:97:8f:d0:a8:90:8c:dd:2e:45:a1:b1:\n"
+        "         e3:8a:82:fc:fc:08:41:01:51:92:87:9a:09:7b:35:c3:cc:48:\n"
+        "         81:39:30:a9:f4:41:3b:06:a3:06:21:cc:4b:bc:1b:76:58:94:\n"
+        "         d1:e4:22:70:7f:20:7e:7a:b4:fa:7f:e8:79:c1:8c:89:9e:e9:\n"
+        "         e3:72:2a:43:72:47:9e:bb:26:ed:64:2c:c8:54:f7:b4:95:c2:\n"
+        "         c4:e9:8b:df:d5:10:a7:ed:a5:7a:94:97:c4:76:45:e3:6c:c0:\n"
+        "         0e:a6:2a:76:d5:1d:2f:ad:99:32:c6:7b:f6:41:e0:65:37:0f:\n"
+        "         c0:1f:c5:99:4a:75:fd:6c:e0:f1:f0:58:49:2d:81:10:ca:d8:\n"
+        "         eb:2b:c3:9b:a9:d9:a9:f5:6c:6d:26:fd:b8:32:92:58:f4:65:\n"
+        "         0b:d1:8e:03:1e:d5:6a:95:d4:46:9e:65:dd:e5:85:36:e6:31:\n"
+        "         77:3a:1a:20:2b:07:b7:f1:9a:4e:8d:54:22:5a:54:1c:72:5c:\n"
+        "         1f:b4:1a:5b:21:ed:06:5a:9a:e5:3c:01:c9:9b:af:50:61:f2:\n"
+        "         29:6b:ec:6d:19:bb:2e:02:94:ca:36:71:ef:45:39:f1:a5:25:\n"
+        "         10:0e:90:bc:a7:b3:5b:ab:af:f1:19:88:6a:09:2f:1f:d0:24:\n"
+        "         a8:62:ed:d9:1a:65:89:65:16:a5:55:de:33:e8:7a:81:66:72:\n"
+        "         91:17:5e:1d:22:72:f7:b8\n"
         "-----BEGIN CERTIFICATE-----\n"
-        "MIIGSDCCBDCgAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwgboxCzAJBgNVBAYTAlVT\n"
-        "MRMwEQYDVQQIDApDYWxpZm9ybmlhMRYwFAYDVQQHDA1TYW4gRnJhbmNpc2NvMRMw\n"
-        "EQYDVQQKDApMaW5kZW4gTGFiMSAwHgYDVQQLDBdTZWNvbmQgTGlmZSBFbmdpbmVl\n"
-        "cmluZzEhMB8GA1UEAwwYSW50ZWdyYXRpb24gVGVzdCBSb290IENBMSQwIgYJKoZI\n"
-        "hvcNAQkBFhVub3JlcGx5QGxpbmRlbmxhYi5jb20wHhcNMTgwNTIyMjIzOTA4WhcN\n"
-        "MjgwNTE5MjIzOTA4WjCBqjELMAkGA1UEBhMCVVMxEzARBgNVBAgMCkNhbGlmb3Ju\n"
-        "aWExEzARBgNVBAoMCkxpbmRlbiBMYWIxIDAeBgNVBAsMF1NlY29uZCBMaWZlIEVu\n"
-        "Z2luZWVyaW5nMSkwJwYDVQQDDCBJbnRlZ3JhdGlvbiBUZXN0IEludGVybWVkaWF0\n"
-        "ZSBDQTEkMCIGCSqGSIb3DQEJARYVbm9yZXBseUBsaW5kZW5sYWIuY29tMIICIjAN\n"
-        "BgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAzqNw4sT7S5eQoTC7wRsTuap+Rhej\n"
-        "Jo1pP15zlehqsQq0j1Bl48ZcOSQ03wu3zM5iDDZaEiz+NUzpHKyAXiSZ16q9vkjA\n"
-        "YmR3NohmzvSo3dJ2JGKQVUH8HRNOp05XvKikWUssWhzYzBbe6IgwyZXfL6YUKA/r\n"
-        "NEYSWLraDubenBX29OOfdKpwiXmL6Vp7GFQVlDojCmV4BdkzkCrOFRgNUvxcMWUg\n"
-        "0BI3jBGAutSwgnMAS0m+y9a8581h8wCYmXRaN4FJln4UARuG0tAGlEBjY0YR/DNc\n"
-        "vTpe1OVER2RQvaaXVXBkmybM3iCCkGqDQZxvcUcUvstofIW+7y52EhnTyYcytKxg\n"
-        "IBYoLa+86AHGf/vYEdX0txS9Jwhbcr4J4JHInHu0sxLvMja+sbmit+NpRzB2upyb\n"
-        "GZlNU91c6CzxsmRpzxW9+LtYlXNYOJW0es+EKabC2/C975cm1Jms18e+sA0R9CaG\n"
-        "LXdCUiXXVsfjl7E2XJdx0Jv1tVCN+f/7EHc8tVNtoUM1qQMyBavX9dEZvV+SowAq\n"
-        "eTekdk/pMg3khrvqwxrFM+gW1KXY4Oi7wvAiFeLZjK6sfSu/66NMOykdlKyju226\n"
-        "bQORA89GEsRmIcXGZ9gRGXkBDm6EHHZvET3rlInFaiYfzeARi1HumTVp5X8LdyqU\n"
-        "5EtkuYMEMAXkouMCAwEAAaNmMGQwHQYDVR0OBBYEFIMh3uzAeQNtHoPz5Zcp1VrA\n"
-        "lkD6MB8GA1UdIwQYMBaAFIoixpwuEfNADM6CDCJZ//h/0LkTMBIGA1UdEwEB/wQI\n"
-        "MAYBAf8CAQAwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4ICAQCjbIWa\n"
-        "Lk5+XYNjD/VPqX3sDm+u17rfZOBGDj3aGBUs83PKgbEQ2VMUIX1yXJSIpZ2tq0VC\n"
-        "xmSp2S5OKUcssZUHt2JIaB9oExzSoPteOCRKggqHyZMgQ37p+XnvA6K9niRrCgFe\n"
-        "SjbFfXr+1qovwow4ipk8sGrlYL5W1utgA1UkQqAa+pEko1MVdV3I63weaFp+EzTj\n"
-        "hTccdj93ZxvtG1IX/Eqj4nSEgCxp/N19JpfEKml9nNxhl3Appz8rWysiUf3+al35\n"
-        "5xRIty3IM1j88l8n9yYWvr61qqJkUzxp6LVh66uRpbQJm/aYuFxbJC+T9SucjFj7\n"
-        "Jj9nU9dCZOh5d3NBTuMCOQu2aJeLhOgdg6gV8QZGR4BCXhTiYYp2hNXUcX9O/9l0\n"
-        "h/8yxYcgCtRZQD7YF+/aZekKUf4ew0aR0u7kI1eXh9SmpevvgWrYjNYfjrEYTGuJ\n"
-        "MlVTaCaeuwO+LOmL/5ecHKwow58Lt5MjJDFj5BkT8rsIcbfFxcQQ/9z8M1SkXuyj\n"
-        "/gqAypy8lW9fOZE7YWkWlA9XS/xLsb5ymF0Q+Qin1uDoPV1UffpLat2YQe2EoTln\n"
-        "XGx/DLDhmMEU7f4e6AWNf2okyxsFQg1/E7rKtZHbpfBAK3B6KqVd7VYM8MJy7mPd\n"
-        "y1129gjm5jDvOrIWNEGk4TAUvMf5IzoacN+4zA==\n"
+        "MIIHNjCCBR6gAwIBAgIJAIW7S2Ym25rGMA0GCSqGSIb3DQEBCwUAMIG6MQswCQYD\n"
+        "VQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNU2FuIEZyYW5j\n"
+        "aXNjbzETMBEGA1UECgwKTGluZGVuIExhYjEgMB4GA1UECwwXU2Vjb25kIExpZmUg\n"
+        "RW5naW5lZXJpbmcxITAfBgNVBAMMGEludGVncmF0aW9uIFRlc3QgUm9vdCBDQTEk\n"
+        "MCIGCSqGSIb3DQEJARYVbm9yZXBseUBsaW5kZW5sYWIuY29tMB4XDTI0MDcyMzEx\n"
+        "NDYzM1oXDTM0MDcyMTExNDYzM1owgcIxCzAJBgNVBAYTAlVTMRMwEQYDVQQIDApD\n"
+        "YWxpZm9ybmlhMRYwFAYDVQQHDA1TYW4gRnJhbmNpc2NvMRMwEQYDVQQKDApMaW5k\n"
+        "ZW4gTGFiMSAwHgYDVQQLDBdTZWNvbmQgTGlmZSBFbmdpbmVlcmluZzEpMCcGA1UE\n"
+        "AwwgSW50ZWdyYXRpb24gVGVzdCBJbnRlcm1lZGlhdGUgQ0ExJDAiBgkqhkiG9w0B\n"
+        "CQEWFW5vcmVwbHlAbGluZGVubGFiLmNvbTCCAiIwDQYJKoZIhvcNAQEBBQADggIP\n"
+        "ADCCAgoCggIBAL730svkXEZ74hEiiXLad3LsBYcZ93cH/WfXrxPVdhKS3WlNIkew\n"
+        "PZSKapWFNLh4w51jMrFLCrYOBXurBiP8DSG1/MZqWja+bvzHR5ejGC4zzQ6KdSu3\n"
+        "KeloSpBTRdtz/7PlwdRr3Tqx71OfI+nGh85nufuk1XYhA8vFcmvFpgdV+0eQ6JI4\n"
+        "cxQRjv8huTVkWmHH/B/kTUflA8wLw2lmcYQMGC9hfzTd8pHjt52ouNs/bm+W+jQG\n"
+        "ggTIGMzei38mtUhT+/sVew44YP7aIZiNcweya/2tIVnnhGbhBBYcvhM0KEMsCT3k\n"
+        "dyqkrW35JgT3Q3Ob2eoaQ2q024j4+b00+Kboequ0suEpR6a6uGWcxrOvE0M47yoF\n"
+        "d5+P8AxWIcKS0izDMlDRYq5R/JnmuDj4gx2NQBHgHVFdP/pVYbYYCR5xr5VknOrG\n"
+        "EWTwqAJ9u8hULldIMnxRZg3WPg7tXjCopkcDZFyJIUWQ4UyRvL2BbnOpFCfmDW04\n"
+        "3FCdslZmYGxmuV27jJYtiV4NK+24AzHOCv+CA/WyO+Un3mHYj7+iamSwSocjQCij\n"
+        "8eyWUM2DUC14cZLyiHWwnc0L5GKmpWMR/LS6n8ZnQCytpO+U8PmguuFSLifZax2C\n"
+        "I+08CwvSvBS+bbFprT4lOmbS0a+fiEUla26+H6Dnsp9tJJQN9MJ1+R9dAgMBAAGj\n"
+        "ggEzMIIBLzAPBgNVHRMECDAGAQH/AgEAMAsGA1UdDwQEAwIBhjAdBgNVHQ4EFgQU\n"
+        "VpjcRSUR4owr6tbG4si+LMhp//8wge8GA1UdIwSB5zCB5IAUTX2uDaVeIlpqjxlh\n"
+        "VLNYy3vAvdqhgcCkgb0wgboxCzAJBgNVBAYTAlVTMRMwEQYDVQQIDApDYWxpZm9y\n"
+        "bmlhMRYwFAYDVQQHDA1TYW4gRnJhbmNpc2NvMRMwEQYDVQQKDApMaW5kZW4gTGFi\n"
+        "MSAwHgYDVQQLDBdTZWNvbmQgTGlmZSBFbmdpbmVlcmluZzEhMB8GA1UEAwwYSW50\n"
+        "ZWdyYXRpb24gVGVzdCBSb290IENBMSQwIgYJKoZIhvcNAQkBFhVub3JlcGx5QGxp\n"
+        "bmRlbmxhYi5jb22CCQDvVNj32hjoGTANBgkqhkiG9w0BAQsFAAOCAgEArtAwrDFJ\n"
+        "IIYLNAFYCJRozDic9xNcRhkz7VRe5EPzWTNcUNmJi+51Z6jHDtEwwk6jLqhkLWqo\n"
+        "9L2xMty8RkhdGhjY6AuM/ntR2d2540vR+eAiRt03W7LLco6cS9pn3/3OhkkhMU6Z\n"
+        "ttQ4CxRdrZe6j+IIFYVz60p9AUmvY64t450K1xHCA9MVIZe+PdLqq8yTFphkgHLr\n"
+        "wngKCWnEK13fMHu+mwI0c2KflbHPCOieV6g3Mc8sjBix1XolkNa2digb4rHPG/Hv\n"
+        "3S/TB6+B41/8Wuc8qTcNnHhbWNyJVHCkW/+fZDCjhRIyaaUCc9kd/2kf1JeP0KiQ\n"
+        "jN0uRaGx44qC/PwIQQFRkoeaCXs1w8xIgTkwqfRBOwajBiHMS7wbdliU0eQicH8g\n"
+        "fnq0+n/oecGMiZ7p43IqQ3JHnrsm7WQsyFT3tJXCxOmL39UQp+2lepSXxHZF42zA\n"
+        "DqYqdtUdL62ZMsZ79kHgZTcPwB/FmUp1/Wzg8fBYSS2BEMrY6yvDm6nZqfVsbSb9\n"
+        "uDKSWPRlC9GOAx7VapXURp5l3eWFNuYxdzoaICsHt/GaTo1UIlpUHHJcH7QaWyHt\n"
+        "Blqa5TwByZuvUGHyKWvsbRm7LgKUyjZx70U58aUlEA6QvKezW6uv8RmIagkvH9Ak\n"
+        "qGLt2RpliWUWpVXeM+h6gWZykRdeHSJy97g=\n"
         "-----END CERTIFICATE-----\n"
-                                           );
+    );
 
     const std::string mPemChildCert(
         "Certificate:\n"
         "    Data:\n"
         "        Version: 3 (0x2)\n"
-        "        Serial Number: 4096 (0x1000)\n"
+        "        Serial Number: 9e:8d:34:13:e7:9b:f9:31\n"
         "    Signature Algorithm: sha256WithRSAEncryption\n"
-        "        Issuer: C=US, ST=California, O=Linden Lab, OU=Second Life Engineering, CN=Integration Test Intermediate CA/emailAddress=noreply@lindenlab.com\n"
+        "        Issuer: C=US, ST=California, L=San Francisco, O=Linden Lab, OU=Second Life Engineering, CN=Integration Test Intermediate CA/emailAddress=noreply@lindenlab.com\n"
         "        Validity\n"
-        "            Not Before: May 22 22:58:15 2018 GMT\n"
-        "            Not After : Jul 19 22:58:15 2024 GMT\n"
+        "            Not Before: Jul 23 11:46:39 2024 GMT\n"
+        "            Not After : Jul 21 11:46:39 2034 GMT\n"
         "        Subject: C=US, ST=California, L=San Francisco, O=Linden Lab, OU=Second Life Engineering, CN=Integration Test Server Cert/emailAddress=noreply@lindenlab.com\n"
         "        Subject Public Key Info:\n"
         "            Public Key Algorithm: rsaEncryption\n"
-        "                Public-Key: (2048 bit)\n"
+        "                Public-Key: (4096 bit)\n"
         "                Modulus:\n"
-        "                    00:bf:a1:1c:76:82:4a:10:1d:25:0e:02:e2:7a:64:\n"
-        "                    54:c7:94:c5:c0:98:d5:35:f3:cb:cb:30:ba:31:9c:\n"
-        "                    bd:4c:2f:4a:4e:24:03:4b:87:5c:c1:5c:fe:d9:89:\n"
-        "                    3b:cb:01:bc:eb:a5:b7:78:dc:b3:58:e5:78:a7:15:\n"
-        "                    34:50:30:aa:16:3a:b2:94:17:6d:1e:7f:b2:70:1e:\n"
-        "                    96:41:bb:1d:e3:22:80:fa:dc:00:6a:fb:34:3e:67:\n"
-        "                    e7:c2:21:2f:1b:d3:af:04:49:91:eb:bb:60:e0:26:\n"
-        "                    52:75:28:8a:08:5b:91:56:4e:51:50:40:51:70:af:\n"
-        "                    cb:80:66:c8:59:e9:e2:48:a8:62:d0:26:67:80:0a:\n"
-        "                    12:16:d1:f6:15:9e:1f:f5:92:37:f3:c9:2f:03:9e:\n"
-        "                    22:f6:60:5a:76:45:8c:01:2c:99:54:72:19:db:b7:\n"
-        "                    72:e6:5a:69:f3:e9:31:65:5d:0f:c7:5c:9c:17:29:\n"
-        "                    71:14:7f:db:47:c9:1e:65:a2:41:b0:2f:14:17:ec:\n"
-        "                    4b:25:f2:43:8f:b4:a3:8d:37:1a:07:34:b3:29:bb:\n"
-        "                    8a:44:8e:84:08:a2:1b:76:7a:cb:c2:39:2f:6e:e3:\n"
-        "                    fc:d6:91:b5:1f:ce:58:91:57:70:35:6e:25:a9:48:\n"
-        "                    0e:07:cf:4e:dd:16:42:65:cf:8a:42:b3:27:e6:fe:\n"
-        "                    6a:e3\n"
+        "                    00:d8:ac:0c:27:8f:ea:c0:4d:21:e4:75:55:31:57:\n"
+        "                    83:46:47:14:1e:f5:67:ae:98:60:c4:97:6d:e8:53:\n"
+        "                    f2:4d:3b:ec:6f:08:bc:1e:c0:e2:a6:75:b5:90:1d:\n"
+        "                    30:a2:59:68:32:10:2b:29:67:fc:99:f1:24:6a:36:\n"
+        "                    73:60:31:6b:c7:a0:b8:b0:38:60:b1:59:23:2c:ab:\n"
+        "                    25:a2:c8:b0:bc:2c:c6:d7:4c:87:37:1b:5e:51:a4:\n"
+        "                    63:3e:c4:6d:ed:da:5e:d3:ad:8a:6d:52:e4:87:38:\n"
+        "                    33:76:cf:f2:86:58:b3:10:a4:91:8d:3d:4f:27:9a:\n"
+        "                    8b:b4:d7:67:90:31:1c:f5:7f:78:af:6f:f2:dd:39:\n"
+        "                    d0:16:16:7b:46:ad:88:1b:3b:74:6b:10:29:8b:64:\n"
+        "                    ba:ed:9f:a7:69:99:55:8f:73:0d:18:a3:7f:40:20:\n"
+        "                    3a:41:4a:94:39:62:8b:fe:c6:9d:79:d0:cd:1c:e2:\n"
+        "                    d4:74:bb:43:75:eb:86:8b:30:c1:8d:cc:14:ab:75:\n"
+        "                    2e:f5:3e:0c:05:cb:e4:c3:92:d8:81:8c:df:a5:4e:\n"
+        "                    2e:0b:ae:17:15:9b:e6:dd:9e:16:46:42:27:92:8a:\n"
+        "                    0e:3a:74:1e:d1:3f:ee:7e:a5:d7:ec:1c:63:d4:96:\n"
+        "                    5b:36:f9:15:ee:da:66:ac:5e:de:91:d9:08:24:fb:\n"
+        "                    5d:fc:9b:77:dd:ff:20:a6:67:6f:48:41:5e:5a:ac:\n"
+        "                    13:a4:2c:2a:f2:a3:15:86:e2:84:33:34:e3:91:27:\n"
+        "                    8b:37:ba:b0:c7:5e:1a:0d:b9:f2:4e:0c:55:e6:bb:\n"
+        "                    d9:63:f5:05:7b:aa:19:e5:57:ce:a5:b1:46:4b:b3:\n"
+        "                    04:f6:a0:97:26:ed:48:ed:97:93:a6:75:b1:a3:42:\n"
+        "                    fc:cc:57:89:da:44:e9:16:a6:30:2c:01:8e:f2:ed:\n"
+        "                    be:45:05:08:8a:af:1e:07:51:89:cf:51:4c:aa:f3:\n"
+        "                    b3:f0:6f:db:21:80:11:32:0a:23:e2:ff:cc:59:15:\n"
+        "                    eb:ff:d2:b8:d6:a1:c1:b4:96:12:82:bf:3f:68:ad:\n"
+        "                    c8:61:50:f8:88:4f:d0:be:8e:29:64:1a:16:a5:d9:\n"
+        "                    29:76:16:cd:70:37:c4:f2:1f:4e:c6:57:36:dd:c1:\n"
+        "                    27:19:72:ef:98:7e:34:25:3f:76:b1:ea:15:b2:38:\n"
+        "                    6e:d3:43:03:7a:2b:78:91:9a:19:26:2a:31:b7:5e:\n"
+        "                    b7:22:c4:fd:bf:93:10:a4:23:3f:d7:79:53:28:5d:\n"
+        "                    2e:ba:0c:b0:5e:0a:b4:c4:a1:71:75:88:1b:b2:0e:\n"
+        "                    2c:67:08:7b:f0:f6:37:d3:aa:39:50:03:a3:7c:17:\n"
+        "                    1d:52:52:2a:6b:d0:a2:54:2e:ba:11:bc:26:a9:16:\n"
+        "                    a6:1b:79\n"
         "                Exponent: 65537 (0x10001)\n"
         "        X509v3 extensions:\n"
-        "            X509v3 Basic Constraints: \n"
+        "            X509v3 Basic Constraints:\n"
         "                CA:FALSE\n"
-        "            Netscape Cert Type: \n"
-        "                SSL Server\n"
-        "            Netscape Comment: \n"
-        "                OpenSSL Generated Server Certificate\n"
-        "            X509v3 Subject Key Identifier: \n"
-        "                BB:59:9F:DE:6B:51:A7:6C:B3:6D:5B:8B:42:F7:B1:65:77:17:A4:E4\n"
-        "            X509v3 Authority Key Identifier: \n"
-        "                keyid:83:21:DE:EC:C0:79:03:6D:1E:83:F3:E5:97:29:D5:5A:C0:96:40:FA\n"
-        "                DirName:/C=US/ST=California/L=San Francisco/O=Linden Lab/OU=Second Life Engineering/CN=Integration Test Root CA/emailAddress=noreply@lindenlab.com\n"
-        "                serial:10:00\n"
-        "\n"
-        "            X509v3 Key Usage: critical\n"
+        "            X509v3 Key Usage:\n"
         "                Digital Signature, Key Encipherment\n"
-        "            X509v3 Extended Key Usage: \n"
+        "            X509v3 Extended Key Usage:\n"
         "                TLS Web Server Authentication\n"
+        "            X509v3 Subject Key Identifier:\n"
+        "                7B:1A:F9:2B:C4:B2:F6:AE:D6:F2:8E:B1:73:FB:DD:11:CA:DB:F8:87\n"
+        "            X509v3 Authority Key Identifier:\n"
+        "                keyid:56:98:DC:45:25:11:E2:8C:2B:EA:D6:C6:E2:C8:BE:2C:C8:69:FF:FF\n"
+        "                DirName:/C=US/ST=California/L=San Francisco/O=Linden Lab/OU=Second Life Engineering/CN=Integration Test Root CA/emailAddress=noreply@lindenlab.com\n"
+        "                serial:85:BB:4B:66:26:DB:9A:C6\n"
         "    Signature Algorithm: sha256WithRSAEncryption\n"
-        "         18:a6:58:55:9b:d4:af:7d:8a:27:d3:28:3a:4c:4b:42:4e:f0:\n"
-        "         30:d6:d9:95:11:48:12:0a:96:40:d9:2b:21:39:c5:d4:8d:e5:\n"
-        "         10:bc:68:78:69:0b:9f:15:4a:0b:f1:ab:99:45:0c:20:5f:27:\n"
-        "         df:e7:14:2d:4a:30:f2:c2:8d:37:73:36:1a:27:55:5a:08:5f:\n"
-        "         71:a1:5e:05:83:b2:59:fe:02:5e:d7:4a:30:15:23:58:04:cf:\n"
-        "         48:cc:b0:71:88:9c:6b:57:f0:04:0a:d3:a0:64:6b:ee:f3:5f:\n"
-        "         ea:ac:e1:2b:b9:7f:79:b8:db:ce:72:48:72:db:c8:5c:38:72:\n"
-        "         31:55:d0:ff:6b:bd:73:23:a7:30:18:5d:ed:47:18:0a:67:8e:\n"
-        "         53:32:0e:99:9b:96:72:45:7f:c6:00:2c:5d:1a:97:53:75:3a:\n"
-        "         0b:49:3d:3a:00:37:14:67:0c:28:97:34:87:aa:c5:32:e4:ae:\n"
-        "         34:83:12:4a:10:f7:0e:74:d4:5f:73:bd:ef:0c:b7:d8:0a:7d:\n"
-        "         8e:8d:5a:48:bd:f4:8e:7b:f9:4a:15:3b:61:c9:5e:40:59:6e:\n"
-        "         c7:a8:a4:02:28:72:c5:54:8c:77:f4:55:a7:86:c0:38:a0:68:\n"
-        "         19:da:0f:72:5a:a9:7e:69:9f:9c:3a:d6:66:aa:e1:f4:fd:f9:\n"
-        "         b8:4b:6c:71:9e:f0:38:02:c7:6a:9e:dc:e6:fb:ef:23:59:4f:\n"
-        "         5c:84:0a:df:ea:86:1f:fd:0e:5c:fa:c4:e5:50:1c:10:cf:89:\n"
-        "         4e:08:0e:4c:4b:61:1a:49:12:f7:e9:4b:17:71:43:7b:6d:b6:\n"
-        "         b5:9f:d4:3b:c7:88:53:48:63:b6:00:80:8f:49:0a:c5:7e:58:\n"
-        "         ac:78:d8:b9:06:b0:bc:86:e2:2e:48:5b:c3:24:fa:aa:72:d8:\n"
-        "         ec:f6:c7:91:9f:0f:c8:b5:fd:2b:b2:a7:bc:2f:40:20:2b:47:\n"
-        "         e0:d1:1d:94:52:6f:6b:be:12:b6:8c:dc:11:db:71:e6:19:ef:\n"
-        "         a8:71:8b:ad:d3:32:c0:1c:a4:3f:b3:0f:af:e5:50:e1:ff:41:\n"
-        "         a4:b7:6f:57:71:af:fd:16:4c:e8:24:b3:99:1b:cf:12:8f:43:\n"
-        "         05:80:ba:18:19:0a:a5:ec:49:81:41:4c:7e:28:b2:21:f2:59:\n"
-        "         6e:4a:ed:de:f9:fa:99:85:60:1f:e6:c2:42:5c:08:00:3c:84:\n"
-        "         06:a9:24:d4:cf:7b:6e:1b:59:1d:f4:70:16:03:a1:e0:0b:00:\n"
-        "         95:5c:39:03:fc:9d:1c:8e:f7:59:0c:61:47:f6:7f:07:22:48:\n"
-        "         83:40:ac:e1:98:5f:c7:be:05:d5:29:2b:bf:0d:03:0e:e9:5e:\n"
-        "         2b:dd:09:18:fe:5e:30:61\n"
+        "         ad:7c:50:12:24:62:62:83:e9:dd:81:1a:12:1c:6d:ae:1e:a6:\n"
+        "         01:cc:93:8b:ac:83:7c:3d:57:d7:7f:d2:13:40:82:c7:27:07:\n"
+        "         31:d8:c4:01:04:64:9c:dc:ae:7b:52:bd:f5:62:7a:d0:7c:13:\n"
+        "         1a:19:86:6a:ce:9a:ba:69:07:77:75:b6:67:56:d0:c3:8d:6f:\n"
+        "         59:5f:ac:31:83:32:2c:4f:8c:85:8c:f3:56:5b:e0:83:16:19:\n"
+        "         c9:55:4d:56:2c:e0:06:f8:71:85:4b:7e:c6:20:b3:f6:5b:85:\n"
+        "         6a:b7:0f:0e:0c:75:38:6a:aa:53:cc:b0:bf:c1:fd:a1:01:8a:\n"
+        "         7e:5a:0b:4d:51:fc:1b:14:b0:8d:62:17:b7:5d:6a:64:30:80:\n"
+        "         aa:50:9a:23:9e:19:46:11:9d:49:d1:35:81:87:80:8c:9c:71:\n"
+        "         61:26:07:23:5d:a7:ea:4e:0c:53:77:bd:eb:18:6d:63:8b:2c:\n"
+        "         e1:83:bb:bb:f8:3e:7c:e8:0d:19:1e:be:35:aa:99:0f:c7:25:\n"
+        "         0c:a8:f9:74:02:c8:4c:8e:bb:13:18:fd:aa:21:34:bc:2d:9f:\n"
+        "         10:96:e2:99:e3:9a:d7:91:0e:1e:77:20:70:e9:b4:63:25:f8:\n"
+        "         ea:14:1f:24:b0:6a:8b:2a:f4:61:b1:0d:7d:18:bc:1d:6d:04:\n"
+        "         11:b2:9f:a2:a7:55:be:2b:2c:2f:c1:d8:95:13:73:af:1c:96:\n"
+        "         49:30:9c:9c:94:81:6c:9b:a7:87:5c:cf:46:95:95:4a:6f:bf:\n"
+        "         df:c9:3d:74:3e:24:6e:44:1e:14:8b:68:23:e4:00:b5:a5:b7:\n"
+        "         5b:a9:ea:16:5f:fa:b1:d3:1a:b1:9b:36:ef:a4:7a:6f:a3:b0:\n"
+        "         97:35:ac:70:c0:cc:8e:a2:d3:40:0e:c1:70:0b:d5:ce:cd:51:\n"
+        "         82:8a:40:72:04:8d:62:af:ba:a8:e7:a8:e9:b9:99:b7:5c:5d:\n"
+        "         27:96:b2:3d:f9:0d:26:8c:3f:db:ac:86:97:be:f1:2c:0b:ca:\n"
+        "         90:07:93:96:f4:75:c3:e8:4c:f6:a8:a2:3f:da:11:21:e7:b1:\n"
+        "         8c:62:36:ae:91:a9:2a:73:ba:67:f5:24:16:c3:ee:b7:b1:b4:\n"
+        "         e3:8a:28:23:84:cf:38:c6:f0:8e:21:f6:b8:76:9a:6d:d1:e3:\n"
+        "         74:81:7a:22:20:a0:82:2a:31:8a:ba:44:0b:61:5a:aa:ba:c6:\n"
+        "         07:99:36:0a:24:06:2f:8e:c1:1c:4b:f0:65:72:fb:e9:b5:31:\n"
+        "         59:13:2c:c6:f8:5b:91:e2:d8:96:f3:1a:06:0b:2a:62:12:4d:\n"
+        "         5e:65:c9:e9:e4:00:99:a6:d3:60:1f:c3:d6:cc:a6:9b:a5:14:\n"
+        "         1b:4d:db:e7:3d:52:7e:2c\n"
         "-----BEGIN CERTIFICATE-----\n"
-        "MIIGbjCCBFagAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwgaoxCzAJBgNVBAYTAlVT\n"
-        "MRMwEQYDVQQIDApDYWxpZm9ybmlhMRMwEQYDVQQKDApMaW5kZW4gTGFiMSAwHgYD\n"
-        "VQQLDBdTZWNvbmQgTGlmZSBFbmdpbmVlcmluZzEpMCcGA1UEAwwgSW50ZWdyYXRp\n"
-        "b24gVGVzdCBJbnRlcm1lZGlhdGUgQ0ExJDAiBgkqhkiG9w0BCQEWFW5vcmVwbHlA\n"
-        "bGluZGVubGFiLmNvbTAeFw0xODA1MjIyMjU4MTVaFw0yNDA3MTkyMjU4MTVaMIG+\n"
-        "MQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNU2Fu\n"
-        "IEZyYW5jaXNjbzETMBEGA1UECgwKTGluZGVuIExhYjEgMB4GA1UECwwXU2Vjb25k\n"
-        "IExpZmUgRW5naW5lZXJpbmcxJTAjBgNVBAMMHEludGVncmF0aW9uIFRlc3QgU2Vy\n"
-        "dmVyIENlcnQxJDAiBgkqhkiG9w0BCQEWFW5vcmVwbHlAbGluZGVubGFiLmNvbTCC\n"
-        "ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL+hHHaCShAdJQ4C4npkVMeU\n"
-        "xcCY1TXzy8swujGcvUwvSk4kA0uHXMFc/tmJO8sBvOult3jcs1jleKcVNFAwqhY6\n"
-        "spQXbR5/snAelkG7HeMigPrcAGr7ND5n58IhLxvTrwRJkeu7YOAmUnUoighbkVZO\n"
-        "UVBAUXCvy4BmyFnp4kioYtAmZ4AKEhbR9hWeH/WSN/PJLwOeIvZgWnZFjAEsmVRy\n"
-        "Gdu3cuZaafPpMWVdD8dcnBcpcRR/20fJHmWiQbAvFBfsSyXyQ4+0o403Ggc0sym7\n"
-        "ikSOhAiiG3Z6y8I5L27j/NaRtR/OWJFXcDVuJalIDgfPTt0WQmXPikKzJ+b+auMC\n"
-        "AwEAAaOCAYYwggGCMAkGA1UdEwQCMAAwEQYJYIZIAYb4QgEBBAQDAgZAMDMGCWCG\n"
-        "SAGG+EIBDQQmFiRPcGVuU1NMIEdlbmVyYXRlZCBTZXJ2ZXIgQ2VydGlmaWNhdGUw\n"
-        "HQYDVR0OBBYEFLtZn95rUadss21bi0L3sWV3F6TkMIHoBgNVHSMEgeAwgd2AFIMh\n"
-        "3uzAeQNtHoPz5Zcp1VrAlkD6oYHApIG9MIG6MQswCQYDVQQGEwJVUzETMBEGA1UE\n"
-        "CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNU2FuIEZyYW5jaXNjbzETMBEGA1UECgwK\n"
-        "TGluZGVuIExhYjEgMB4GA1UECwwXU2Vjb25kIExpZmUgRW5naW5lZXJpbmcxITAf\n"
-        "BgNVBAMMGEludGVncmF0aW9uIFRlc3QgUm9vdCBDQTEkMCIGCSqGSIb3DQEJARYV\n"
-        "bm9yZXBseUBsaW5kZW5sYWIuY29tggIQADAOBgNVHQ8BAf8EBAMCBaAwEwYDVR0l\n"
-        "BAwwCgYIKwYBBQUHAwEwDQYJKoZIhvcNAQELBQADggIBABimWFWb1K99iifTKDpM\n"
-        "S0JO8DDW2ZURSBIKlkDZKyE5xdSN5RC8aHhpC58VSgvxq5lFDCBfJ9/nFC1KMPLC\n"
-        "jTdzNhonVVoIX3GhXgWDsln+Al7XSjAVI1gEz0jMsHGInGtX8AQK06Bka+7zX+qs\n"
-        "4Su5f3m4285ySHLbyFw4cjFV0P9rvXMjpzAYXe1HGApnjlMyDpmblnJFf8YALF0a\n"
-        "l1N1OgtJPToANxRnDCiXNIeqxTLkrjSDEkoQ9w501F9zve8Mt9gKfY6NWki99I57\n"
-        "+UoVO2HJXkBZbseopAIocsVUjHf0VaeGwDigaBnaD3JaqX5pn5w61maq4fT9+bhL\n"
-        "bHGe8DgCx2qe3Ob77yNZT1yECt/qhh/9Dlz6xOVQHBDPiU4IDkxLYRpJEvfpSxdx\n"
-        "Q3tttrWf1DvHiFNIY7YAgI9JCsV+WKx42LkGsLyG4i5IW8Mk+qpy2Oz2x5GfD8i1\n"
-        "/Suyp7wvQCArR+DRHZRSb2u+EraM3BHbceYZ76hxi63TMsAcpD+zD6/lUOH/QaS3\n"
-        "b1dxr/0WTOgks5kbzxKPQwWAuhgZCqXsSYFBTH4osiHyWW5K7d75+pmFYB/mwkJc\n"
-        "CAA8hAapJNTPe24bWR30cBYDoeALAJVcOQP8nRyO91kMYUf2fwciSINArOGYX8e+\n"
-        "BdUpK78NAw7pXivdCRj+XjBh\n"
+        "MIIHSTCCBTGgAwIBAgIJAJ6NNBPnm/kxMA0GCSqGSIb3DQEBCwUAMIHCMQswCQYD\n"
+        "VQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNU2FuIEZyYW5j\n"
+        "aXNjbzETMBEGA1UECgwKTGluZGVuIExhYjEgMB4GA1UECwwXU2Vjb25kIExpZmUg\n"
+        "RW5naW5lZXJpbmcxKTAnBgNVBAMMIEludGVncmF0aW9uIFRlc3QgSW50ZXJtZWRp\n"
+        "YXRlIENBMSQwIgYJKoZIhvcNAQkBFhVub3JlcGx5QGxpbmRlbmxhYi5jb20wHhcN\n"
+        "MjQwNzIzMTE0NjM5WhcNMzQwNzIxMTE0NjM5WjCBvjELMAkGA1UEBhMCVVMxEzAR\n"
+        "BgNVBAgMCkNhbGlmb3JuaWExFjAUBgNVBAcMDVNhbiBGcmFuY2lzY28xEzARBgNV\n"
+        "BAoMCkxpbmRlbiBMYWIxIDAeBgNVBAsMF1NlY29uZCBMaWZlIEVuZ2luZWVyaW5n\n"
+        "MSUwIwYDVQQDDBxJbnRlZ3JhdGlvbiBUZXN0IFNlcnZlciBDZXJ0MSQwIgYJKoZI\n"
+        "hvcNAQkBFhVub3JlcGx5QGxpbmRlbmxhYi5jb20wggIiMA0GCSqGSIb3DQEBAQUA\n"
+        "A4ICDwAwggIKAoICAQDYrAwnj+rATSHkdVUxV4NGRxQe9WeumGDEl23oU/JNO+xv\n"
+        "CLwewOKmdbWQHTCiWWgyECspZ/yZ8SRqNnNgMWvHoLiwOGCxWSMsqyWiyLC8LMbX\n"
+        "TIc3G15RpGM+xG3t2l7TrYptUuSHODN2z/KGWLMQpJGNPU8nmou012eQMRz1f3iv\n"
+        "b/LdOdAWFntGrYgbO3RrECmLZLrtn6dpmVWPcw0Yo39AIDpBSpQ5Yov+xp150M0c\n"
+        "4tR0u0N164aLMMGNzBSrdS71PgwFy+TDktiBjN+lTi4LrhcVm+bdnhZGQieSig46\n"
+        "dB7RP+5+pdfsHGPUlls2+RXu2masXt6R2Qgk+138m3fd/yCmZ29IQV5arBOkLCry\n"
+        "oxWG4oQzNOORJ4s3urDHXhoNufJODFXmu9lj9QV7qhnlV86lsUZLswT2oJcm7Ujt\n"
+        "l5OmdbGjQvzMV4naROkWpjAsAY7y7b5FBQiKrx4HUYnPUUyq87Pwb9shgBEyCiPi\n"
+        "/8xZFev/0rjWocG0lhKCvz9orchhUPiIT9C+jilkGhal2Sl2Fs1wN8TyH07GVzbd\n"
+        "wScZcu+YfjQlP3ax6hWyOG7TQwN6K3iRmhkmKjG3XrcixP2/kxCkIz/XeVMoXS66\n"
+        "DLBeCrTEoXF1iBuyDixnCHvw9jfTqjlQA6N8Fx1SUipr0KJULroRvCapFqYbeQID\n"
+        "AQABo4IBQjCCAT4wCQYDVR0TBAIwADALBgNVHQ8EBAMCBaAwEwYDVR0lBAwwCgYI\n"
+        "KwYBBQUHAwEwHQYDVR0OBBYEFHsa+SvEsvau1vKOsXP73RHK2/iHMIHvBgNVHSME\n"
+        "gecwgeSAFFaY3EUlEeKMK+rWxuLIvizIaf//oYHApIG9MIG6MQswCQYDVQQGEwJV\n"
+        "UzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNU2FuIEZyYW5jaXNjbzET\n"
+        "MBEGA1UECgwKTGluZGVuIExhYjEgMB4GA1UECwwXU2Vjb25kIExpZmUgRW5naW5l\n"
+        "ZXJpbmcxITAfBgNVBAMMGEludGVncmF0aW9uIFRlc3QgUm9vdCBDQTEkMCIGCSqG\n"
+        "SIb3DQEJARYVbm9yZXBseUBsaW5kZW5sYWIuY29tggkAhbtLZibbmsYwDQYJKoZI\n"
+        "hvcNAQELBQADggIBAK18UBIkYmKD6d2BGhIcba4epgHMk4usg3w9V9d/0hNAgscn\n"
+        "BzHYxAEEZJzcrntSvfVietB8ExoZhmrOmrppB3d1tmdW0MONb1lfrDGDMixPjIWM\n"
+        "81Zb4IMWGclVTVYs4Ab4cYVLfsYgs/ZbhWq3Dw4MdThqqlPMsL/B/aEBin5aC01R\n"
+        "/BsUsI1iF7ddamQwgKpQmiOeGUYRnUnRNYGHgIyccWEmByNdp+pODFN3vesYbWOL\n"
+        "LOGDu7v4PnzoDRkevjWqmQ/HJQyo+XQCyEyOuxMY/aohNLwtnxCW4pnjmteRDh53\n"
+        "IHDptGMl+OoUHySwaosq9GGxDX0YvB1tBBGyn6KnVb4rLC/B2JUTc68clkkwnJyU\n"
+        "gWybp4dcz0aVlUpvv9/JPXQ+JG5EHhSLaCPkALWlt1up6hZf+rHTGrGbNu+kem+j\n"
+        "sJc1rHDAzI6i00AOwXAL1c7NUYKKQHIEjWKvuqjnqOm5mbdcXSeWsj35DSaMP9us\n"
+        "hpe+8SwLypAHk5b0dcPoTPaooj/aESHnsYxiNq6RqSpzumf1JBbD7rextOOKKCOE\n"
+        "zzjG8I4h9rh2mm3R43SBeiIgoIIqMYq6RAthWqq6xgeZNgokBi+OwRxL8GVy++m1\n"
+        "MVkTLMb4W5Hi2JbzGgYLKmISTV5lyenkAJmm02Afw9bMppulFBtN2+c9Un4s\n"
         "-----END CERTIFICATE-----\n"
-                                    );
+    );
+
 
     // Test wrapper declaration : wrapping nothing for the moment
     struct sechandler_basic_test
@@ -701,14 +722,13 @@ namespace tut
         //std::ostringstream llsd_value;
         //llsd_value << LLSDOStreamer<LLSDNotationFormatter>(llsd_cert) << std::endl;
         LL_DEBUGS() << "test 1 cert " << llsd_cert << LL_ENDL;
-
         ensure_equals("Issuer Name/commonName", (std::string)llsd_cert["issuer_name"]["commonName"], "Integration Test Intermediate CA");
         ensure_equals("Issuer Name/countryName", (std::string)llsd_cert["issuer_name"]["countryName"], "US");
         ensure_equals("Issuer Name/state", (std::string)llsd_cert["issuer_name"]["stateOrProvinceName"], "California");
         ensure_equals("Issuer Name/org name", (std::string)llsd_cert["issuer_name"]["organizationName"], "Linden Lab");
         ensure_equals("Issuer Name/org unit", (std::string)llsd_cert["issuer_name"]["organizationalUnitName"], "Second Life Engineering");
         ensure_equals("Issuer name string", (std::string)llsd_cert["issuer_name_string"],
-                      "emailAddress=noreply@lindenlab.com,CN=Integration Test Intermediate CA,OU=Second Life Engineering,O=Linden Lab,ST=California,C=US");
+                      "emailAddress=noreply@lindenlab.com,CN=Integration Test Intermediate CA,OU=Second Life Engineering,O=Linden Lab,L=San Francisco,ST=California,C=US");
         ensure_equals("subject Name/commonName", (std::string)llsd_cert["subject_name"]["commonName"],
                       "Integration Test Server Cert");
         ensure_equals("subject Name/countryName", (std::string)llsd_cert["subject_name"]["countryName"], "US");
@@ -721,9 +741,9 @@ namespace tut
         ensure_equals("subject name string",
                (std::string)llsd_cert["subject_name_string"],
                       "emailAddress=noreply@lindenlab.com,CN=Integration Test Server Cert,OU=Second Life Engineering,O=Linden Lab,L=San Francisco,ST=California,C=US");
-        ensure_equals("serial number", (std::string)llsd_cert["serial_number"], "1000");
-        ensure_equals("valid from", (std::string)llsd_cert["valid_from"], "2018-05-22T22:58:15Z");
-        ensure_equals("valid to", (std::string)llsd_cert["valid_to"], "2024-07-19T22:58:15Z");
+        ensure_equals("serial number", (std::string)llsd_cert["serial_number"], "9E8D3413E79BF931");
+        ensure_equals("valid from", (std::string)llsd_cert["valid_from"], "2024-07-23T11:46:39Z");
+        ensure_equals("valid to", (std::string)llsd_cert["valid_to"], "2034-07-21T11:46:39Z");
         LLSD expectedKeyUsage = LLSD::emptyArray();
         expectedKeyUsage.append(LLSD((std::string)"digitalSignature"));
         expectedKeyUsage.append(LLSD((std::string)"keyEncipherment"));
@@ -1042,7 +1062,7 @@ namespace tut
 
         //validate find
         LLSD find_info = LLSD::emptyMap();
-        find_info["subjectKeyIdentifier"] = "bb:59:9f:de:6b:51:a7:6c:b3:6d:5b:8b:42:f7:b1:65:77:17:a4:e4";
+        find_info["subjectKeyIdentifier"] = "7b:1a:f9:2b:c4:b2:f6:ae:d6:f2:8e:b1:73:fb:dd:11:ca:db:f8:87";
         LLBasicCertificateVector::iterator found_cert = test_vector->find(find_info);
         ensure("found some cert", found_cert != test_vector->end());
         X509* found_x509 = (*found_cert).get()->getOpenSSLX509();
@@ -1225,7 +1245,7 @@ namespace tut
         X509_STORE_CTX_set0_untrusted(test_store, NULL);
         test_chain = new LLBasicCertificateChain(test_store);
         X509_STORE_CTX_free(test_store);
-        ensure_equals("two elements in store", test_chain->size(), 1);
+        ensure_equals("two elements in store [1]", test_chain->size(), 1);
         X509* test_cert = (*test_chain)[0]->getOpenSSLX509();
         ensure("validate first element in store is expected cert", !X509_cmp(test_cert, mX509ChildCert));
         X509_free(test_cert);
@@ -1238,7 +1258,7 @@ namespace tut
         sk_X509_push(X509_STORE_CTX_get0_untrusted(test_store), mX509IntermediateCert);
         test_chain = new LLBasicCertificateChain(test_store);
         X509_STORE_CTX_free(test_store);
-        ensure_equals("two elements in store", test_chain->size(), 2);
+        ensure_equals("two elements in store [2]", test_chain->size(), 2);
         test_cert = (*test_chain)[0]->getOpenSSLX509();
         ensure("validate first element in store is expected cert", !X509_cmp(test_cert, mX509ChildCert));
         X509_free(test_cert);
@@ -1254,7 +1274,7 @@ namespace tut
         sk_X509_push(X509_STORE_CTX_get0_untrusted(test_store), mX509TestCert);
         test_chain = new LLBasicCertificateChain(test_store);
         X509_STORE_CTX_free(test_store);
-        ensure_equals("two elements in store", test_chain->size(), 1);
+        ensure_equals("two elements in store [3]", test_chain->size(), 1);
         test_cert = (*test_chain)[0]->getOpenSSLX509();
         ensure("validate first element in store is expected cert", !X509_cmp(test_cert, mX509ChildCert));
         X509_free(test_cert);
@@ -1267,7 +1287,7 @@ namespace tut
         sk_X509_push(X509_STORE_CTX_get0_untrusted(test_store), mX509TestCert);
         test_chain = new LLBasicCertificateChain(test_store);
         X509_STORE_CTX_free(test_store);
-        ensure_equals("two elements in store", test_chain->size(), 2);
+        ensure_equals("two elements in store [4]", test_chain->size(), 2);
         test_cert = (*test_chain)[0]->getOpenSSLX509();
         ensure("validate first element in store is expected cert", !X509_cmp(test_cert, mX509ChildCert));
         X509_free(test_cert);

From 06c90a6fecb88f7062e366ce7aa400dd6a2d937a Mon Sep 17 00:00:00 2001
From: Brad Linden <46733234+brad-linden@users.noreply.github.com>
Date: Tue, 23 Jul 2024 09:54:19 -0700
Subject: [PATCH 02/30] Clarify environment info prompt for bug issue template.
 (#2088)

---
 .github/ISSUE_TEMPLATE/10-bug.yaml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/ISSUE_TEMPLATE/10-bug.yaml b/.github/ISSUE_TEMPLATE/10-bug.yaml
index 41208e8bf5..612f71ace6 100644
--- a/.github/ISSUE_TEMPLATE/10-bug.yaml
+++ b/.github/ISSUE_TEMPLATE/10-bug.yaml
@@ -11,8 +11,8 @@ body:
 - type: textarea
   attributes:
     label: Environment
-    description: About Second Life Text
-    placeholder: ex. Second Life Test 7.1.3.240191747 (64bit) ...
+    description: "Please copy the info from the viewer's 'About Second Life' window and paste it here:"
+    placeholder: 'ex. Second Life Release 7.1.8.9375512768 (64bit) ...'
   validations:
     required: true
 

From 57e78ed43b61864a6b8a54df95d8823daaeb5fe8 Mon Sep 17 00:00:00 2001
From: Andrey Kleshchev <andreykproductengine@lindenlab.com>
Date: Tue, 23 Jul 2024 11:22:09 +0300
Subject: [PATCH 03/30] viewer#2043 bugsplat symbol upload update

---
 .github/workflows/build.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml
index aa504f51d8..68fdc3c2bf 100644
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@@ -395,7 +395,7 @@ jobs:
           password: ${{ env.BUGSPLAT_PASS }}
           database: "SecondLife_Viewer_2018"
           channel: ${{ needs.build.outputs.viewer_channel }}
-          version: ${{ needs.build.outputs.viewer_version }}
+          version: ${{ needs.build.outputs.viewer_version }} (${{ needs.build.outputs.viewer_version }})
 
   release:
     needs: [setvar, build, sign-and-package-windows, sign-and-package-mac]

From aaa5caeca89cb08f785fec1785d8edeca6eda0ae Mon Sep 17 00:00:00 2001
From: Alexander Gavriliuk <alexandrgproductengine@lindenlab.com>
Date: Tue, 23 Jul 2024 10:45:57 +0200
Subject: [PATCH 04/30] #1318 Pagination in the Group Interface

---
 indra/llui/llscrolllistctrl.cpp      |  41 ++--
 indra/newview/llgroupmgr.cpp         | 272 ++++++++++++++-------------
 indra/newview/llgroupmgr.h           |  16 +-
 indra/newview/llpanelgroupbulk.cpp   | 213 ++++++++++-----------
 indra/newview/llpanelgroupbulkimpl.h |   5 +-
 indra/newview/llpanelgrouproles.cpp  | 259 ++++++++++---------------
 6 files changed, 379 insertions(+), 427 deletions(-)

diff --git a/indra/llui/llscrolllistctrl.cpp b/indra/llui/llscrolllistctrl.cpp
index 1d9564d107..8512555b49 100644
--- a/indra/llui/llscrolllistctrl.cpp
+++ b/indra/llui/llscrolllistctrl.cpp
@@ -1479,10 +1479,9 @@ const std::string LLScrollListCtrl::getSelectedItemLabel(S32 column) const
     item = getFirstSelected();
     if (item)
     {
-        auto col = item->getColumn(column);
-        if(col)
+        if (LLScrollListCell* cell = item->getColumn(column))
         {
-            return col->getValue().asString();
+            return cell->getValue().asString();
         }
     }
 
@@ -2720,7 +2719,8 @@ struct SameSortColumn
 bool LLScrollListCtrl::setSort(S32 column_idx, bool ascending)
 {
     LLScrollListColumn* sort_column = getColumn(column_idx);
-    if (!sort_column) return false;
+    if (!sort_column)
+        return false;
 
     sort_column->mSortDirection = ascending ? LLScrollListColumn::ASCENDING : LLScrollListColumn::DESCENDING;
 
@@ -2733,32 +2733,28 @@ bool LLScrollListCtrl::setSort(S32 column_idx, bool ascending)
         mSortColumns.push_back(new_sort_column);
         return true;
     }
-    else
-    {
-        // grab current sort column
-        sort_column_t cur_sort_column = mSortColumns.back();
 
-        // remove any existing sort criterion referencing this column
-        // and add the new one
-        mSortColumns.erase(remove_if(mSortColumns.begin(), mSortColumns.end(), SameSortColumn(column_idx)), mSortColumns.end());
-        mSortColumns.push_back(new_sort_column);
+    // grab current sort column
+    sort_column_t cur_sort_column = mSortColumns.back();
 
-        // did the sort criteria change?
-        return (cur_sort_column != new_sort_column);
-    }
+    // remove any existing sort criterion referencing this column
+    // and add the new one
+    mSortColumns.erase(remove_if(mSortColumns.begin(), mSortColumns.end(), SameSortColumn(column_idx)), mSortColumns.end());
+    mSortColumns.push_back(new_sort_column);
+
+    // did the sort criteria change?
+    return cur_sort_column != new_sort_column;
 }
 
 S32 LLScrollListCtrl::getLinesPerPage()
 {
-    //if mPageLines is NOT provided display all item
     if (mPageLines)
     {
         return mPageLines;
     }
-    else
-    {
-        return mLineHeight ? mItemListRect.getHeight() / mLineHeight : getItemCount();
-    }
+
+    // If mPageLines is NOT provided then display all items
+    return mLineHeight ? mItemListRect.getHeight() / mLineHeight : getItemCount();
 }
 
 
@@ -2774,7 +2770,7 @@ void LLScrollListCtrl::sortByColumn(const std::string& name, bool ascending)
     column_map_t::iterator itor = mColumns.find(name);
     if (itor != mColumns.end())
     {
-        sortByColumnIndex((*itor).second->mIndex, ascending);
+        sortByColumnIndex(itor->second->mIndex, ascending);
     }
 }
 
@@ -3093,8 +3089,7 @@ std::string LLScrollListCtrl::getSortColumnName()
 {
     LLScrollListColumn* column = mSortColumns.empty() ? NULL : mColumnsIndexed[mSortColumns.back().first];
 
-    if (column) return column->mName;
-    else return "";
+    return column ? column->mName : LLStringUtil::null;
 }
 
 bool LLScrollListCtrl::hasSortOrder() const
diff --git a/indra/newview/llgroupmgr.cpp b/indra/newview/llgroupmgr.cpp
index 1057bc25e0..090ed7b0e2 100644
--- a/indra/newview/llgroupmgr.cpp
+++ b/indra/newview/llgroupmgr.cpp
@@ -806,7 +806,7 @@ void LLGroupMgrGroupData::banMemberById(const LLUUID& participant_uuid)
 
     mPendingBanRequest = false;
 
-    LLGroupMemberData* member_data = (*mi).second;
+    LLGroupMemberData* member_data = mi->second;
     if (member_data && member_data->isInRole(mOwnerRole))
     {
         return; // can't ban group owner
@@ -832,8 +832,7 @@ void LLGroupMgrGroupData::banMemberById(const LLUUID& participant_uuid)
 // LLGroupMgr
 //
 
-LLGroupMgr::LLGroupMgr():
-    mMemberRequestInFlight(false)
+LLGroupMgr::LLGroupMgr()
 {
 }
 
@@ -968,11 +967,11 @@ void LLGroupMgr::processGroupMembersReply(LLMessageSystem* msg, void** data)
     LLGroupMgrGroupData* group_datap = LLGroupMgr::getInstance()->getGroupData(group_id);
     if (!group_datap || (group_datap->mMemberRequestID != request_id))
     {
-        LL_WARNS() << "processGroupMembersReply: Received incorrect (stale?) group or request id" << LL_ENDL;
+        LL_WARNS() << "Received incorrect (stale?) group or request id" << LL_ENDL;
         return;
     }
 
-    msg->getS32(_PREHASH_GroupData, "MemberCount", group_datap->mMemberCount );
+    msg->getS32Fast(_PREHASH_GroupData, _PREHASH_MemberCount, group_datap->mMemberCount);
 
     if (group_datap->mMemberCount > 0)
     {
@@ -987,12 +986,12 @@ void LLGroupMgr::processGroupMembersReply(LLMessageSystem* msg, void** data)
         {
             LLUUID member_id;
 
-            msg->getUUIDFast(_PREHASH_MemberData, _PREHASH_AgentID, member_id, i );
-            msg->getS32(_PREHASH_MemberData, _PREHASH_Contribution, contribution, i);
-            msg->getU64(_PREHASH_MemberData, "AgentPowers", agent_powers, i);
+            msg->getUUIDFast(_PREHASH_MemberData, _PREHASH_AgentID, member_id, i);
+            msg->getS32Fast(_PREHASH_MemberData, _PREHASH_Contribution, contribution, i);
+            msg->getU64Fast(_PREHASH_MemberData, _PREHASH_AgentPowers, agent_powers, i);
             msg->getStringFast(_PREHASH_MemberData, _PREHASH_OnlineStatus, online_status, i);
-            msg->getString(_PREHASH_MemberData, "Title", title, i);
-            msg->getBOOL(_PREHASH_MemberData,"IsOwner",is_owner,i);
+            msg->getStringFast(_PREHASH_MemberData, _PREHASH_Title, title, i);
+            msg->getBOOLFast(_PREHASH_MemberData, _PREHASH_IsOwner, is_owner, i);
 
             if (member_id.notNull())
             {
@@ -1037,7 +1036,7 @@ void LLGroupMgr::processGroupMembersReply(LLMessageSystem* msg, void** data)
 
     group_datap->mMemberVersion.generate();
 
-    if (group_datap->mMembers.size() ==  (U32)group_datap->mMemberCount)
+    if (group_datap->mMembers.size() == (U32)group_datap->mMemberCount)
     {
         group_datap->mMemberDataComplete = true;
         group_datap->mMemberRequestID.setNull();
@@ -1678,13 +1677,12 @@ void LLGroupMgr::sendGroupRoleMembersRequest(const LLUUID& group_id)
     if (group_datap->mRoleMembersRequestID.isNull())
     {
         // Don't send the request if we don't have all the member or role data
-        if (!group_datap->isMemberDataComplete()
-            || !group_datap->isRoleDataComplete())
+        if (!group_datap->isMemberDataComplete() || !group_datap->isRoleDataComplete())
         {
             // *TODO: KLW FIXME: Should we start a member or role data request?
             LL_INFOS("GrpMgr") << " Pending: " << (group_datap->mPendingRoleMemberRequest ? "Y" : "N")
-                << " MemberDataComplete: " << (group_datap->mMemberDataComplete ? "Y" : "N")
-                << " RoleDataComplete: " << (group_datap->mRoleDataComplete ? "Y" : "N") << LL_ENDL;
+                << ", MemberDataComplete: " << (group_datap->mMemberDataComplete ? "Y" : "N")
+                << ", RoleDataComplete: " << (group_datap->mRoleDataComplete ? "Y" : "N") << LL_ENDL;
             group_datap->mPendingRoleMemberRequest = true;
             return;
         }
@@ -1984,14 +1982,14 @@ void LLGroupMgr::sendGroupMemberEjects(const LLUUID& group_id,
     group_datap->mMemberVersion.generate();
 }
 
-void LLGroupMgr::getGroupBanRequestCoro(std::string url, LLUUID groupId)
+void LLGroupMgr::getGroupBanRequestCoro(std::string url, LLUUID group_id)
 {
     LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("groupMembersRequest", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
 
-    std::string finalUrl = url + "?group_id=" + groupId.asString();
+    std::string finalUrl = url + "?group_id=" + group_id.asString();
 
     LLSD result = httpAdapter->getAndSuspend(httpRequest, finalUrl);
 
@@ -2012,8 +2010,8 @@ void LLGroupMgr::getGroupBanRequestCoro(std::string url, LLUUID groupId)
     }
 }
 
-void LLGroupMgr::postGroupBanRequestCoro(std::string url, LLUUID groupId,
-    U32 action, uuid_vec_t banList, bool update)
+void LLGroupMgr::postGroupBanRequestCoro(std::string url, LLUUID group_id,
+    U32 action, uuid_vec_t ban_list, bool update)
 {
     LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
@@ -2026,20 +2024,16 @@ void LLGroupMgr::postGroupBanRequestCoro(std::string url, LLUUID groupId,
 
     httpHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, HTTP_CONTENT_LLSD_XML);
 
-
-    std::string finalUrl = url + "?group_id=" + groupId.asString();
+    std::string finalUrl = url + "?group_id=" + group_id.asString();
 
     LLSD postData = LLSD::emptyMap();
     postData["ban_action"] = (LLSD::Integer)action;
     // Add our list of potential banned residents to the list
     postData["ban_ids"] = LLSD::emptyArray();
-    LLSD banEntry;
 
-    uuid_vec_t::const_iterator it = banList.begin();
-    for (; it != banList.end(); ++it)
+    for (const LLUUID& ban_id : ban_list)
     {
-        banEntry = (*it);
-        postData["ban_ids"].append(banEntry);
+        postData["ban_ids"].append(ban_id);
     }
 
     LL_WARNS() << "post: " << ll_pretty_print_sd(postData) << LL_ENDL;
@@ -2064,7 +2058,7 @@ void LLGroupMgr::postGroupBanRequestCoro(std::string url, LLUUID groupId,
 
     if (update)
     {
-        getGroupBanRequestCoro(url, groupId);
+        getGroupBanRequestCoro(url, group_id);
     }
 }
 
@@ -2151,55 +2145,66 @@ void LLGroupMgr::processGroupBanRequest(const LLSD& content)
     LLGroupMgr::getInstance()->notifyObservers(GC_BANLIST);
 }
 
-void LLGroupMgr::groupMembersRequestCoro(std::string url, LLUUID groupId)
+void LLGroupMgr::groupMembersRequestCoro(std::string url, LLUUID group_id, U32 page_size, U32 page_start, std::string sort_column)
 {
+    LL_INFOS("GrpMgr") << "group_id: '" << group_id << "', sort_column: '" << sort_column << "', page_size: " << page_size << ", page_start: " << page_start << LL_ENDL;
     LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("groupMembersRequest", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions);
-
-    mMemberRequestInFlight = true;
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
 
     LLSD postData = LLSD::emptyMap();
-    postData["group_id"] = groupId;
+    postData["group_id"] = group_id;
+    if (page_size)
+    {
+        postData["page_size"] = LLSD::Integer(page_size);
+        if (page_start)
+        {
+            postData["page_start"] = LLSD::Integer(page_start);
+        }
+        if (!sort_column.empty())
+        {
+            postData["sort_column"] = sort_column;
+        }
+    }
 
-    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, postData, httpOpts);
+    LLSD response = httpAdapter->postAndSuspend(httpRequest, url, postData, httpOpts);
 
-    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
+    mMemberRequestInFlight = false;
+
+    LLSD httpResults = response.get(LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS);
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
 
     if (!status)
     {
         LL_WARNS("GrpMgr") << "Error receiving group member data " << LL_ENDL;
-        mMemberRequestInFlight = false;
         return;
     }
 
-    result.erase(LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS);
-    LLGroupMgr::processCapGroupMembersRequest(result);
-    mMemberRequestInFlight = false;
+    response.erase(LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS);
+    processCapGroupMembersResponse(response, page_size, page_start, sort_column);
 }
 
-void LLGroupMgr::sendCapGroupMembersRequest(const LLUUID& group_id)
+void LLGroupMgr::sendCapGroupMembersRequest(const LLUUID& group_id, U32 page_size, U32 page_start, const std::string& sort_column)
 {
     static U32 lastGroupMemberRequestFrame = 0;
 
     // Have we requested the information already this frame?
     // Todo: make this per group, we can invite to one group and simultaneously be checking another one
-    if ((lastGroupMemberRequestFrame == gFrameCount) || (mMemberRequestInFlight))
+    if ((lastGroupMemberRequestFrame == gFrameCount) || mMemberRequestInFlight)
         return;
 
     LLViewerRegion* currentRegion = gAgent.getRegion();
     // Thank you FS:Ansariel!
-    if(!currentRegion)
+    if (!currentRegion)
     {
         LL_WARNS("GrpMgr") << "Agent does not have a current region. Uh-oh!" << LL_ENDL;
         return;
     }
 
     // Check to make sure we have our capabilities
-    if(!currentRegion->capabilitiesReceived())
+    if (!currentRegion->capabilitiesReceived())
     {
         LL_WARNS("GrpMgr") << " Capabilities not received!" << LL_ENDL;
         return;
@@ -2209,9 +2214,9 @@ void LLGroupMgr::sendCapGroupMembersRequest(const LLUUID& group_id)
     std::string cap_url =  currentRegion->getCapability("GroupMemberData");
 
     // Thank you FS:Ansariel!
-    if(cap_url.empty())
+    if (cap_url.empty())
     {
-        LL_INFOS("GrpMgr") << "Region has no GroupMemberData capability.  Falling back to UDP fetch." << LL_ENDL;
+        LL_INFOS("GrpMgr") << "Region has no GroupMemberData capability. Falling back to UDP fetch." << LL_ENDL;
         sendGroupMembersRequest(group_id);
         return;
     }
@@ -2221,120 +2226,121 @@ void LLGroupMgr::sendCapGroupMembersRequest(const LLUUID& group_id)
 
     lastGroupMemberRequestFrame = gFrameCount;
 
-    LLCoros::instance().launch("LLGroupMgr::groupMembersRequestCoro",
-        boost::bind(&LLGroupMgr::groupMembersRequestCoro, this, cap_url, group_id));
+    mMemberRequestInFlight = true;
+
+    LLCoros::instance().launch("LLGroupMgr::groupMembersRequestCoro", [&]()
+        {
+            groupMembersRequestCoro(cap_url, group_id, page_size, page_start, sort_column);
+        });
 }
 
-
-void LLGroupMgr::processCapGroupMembersRequest(const LLSD& content)
+void LLGroupMgr::processCapGroupMembersResponse(const LLSD& response, U32 page_size, U32 page_start, const std::string& sort_column)
 {
+    LLUUID group_id = response["group_id"].asUUID();
+    LL_INFOS("GrpMgr") << "group_id: '" << group_id << "', sort_column: '" << sort_column << "', page_size: " << page_size << ", page_start: " << page_start << LL_ENDL;
+
     // Did we get anything in content?
-    if(!content.size())
+    if (!response.size())
     {
-        LL_DEBUGS("GrpMgr") << "No group member data received." << LL_ENDL;
+        LL_INFOS("GrpMgr") << "No group member data received." << LL_ENDL;
         return;
     }
 
-    LLUUID group_id = content["group_id"].asUUID();
-
     LLGroupMgrGroupData* group_datap = getGroupData(group_id);
-    if(!group_datap)
+    if (!group_datap)
     {
         LL_WARNS("GrpMgr") << "Received incorrect, possibly stale, group or request id" << LL_ENDL;
         return;
     }
 
-    // If we have no members, there's no reason to do anything else
-    S32 num_members = content["member_count"];
-    if (num_members < 1)
-    {
-        LL_INFOS("GrpMgr") << "Received empty group members list for group id: " << group_id.asString() << LL_ENDL;
-        // Set mMemberDataComplete for correct handling of empty responses. See MAINT-5237
-        group_datap->mMemberDataComplete = true;
-        group_datap->mChanged = true;
-        LLGroupMgr::getInstance()->notifyObservers(GC_MEMBER_DATA);
-        return;
-    }
+    LLSD members = response["members"];
+    LLSD titles = response["titles"];
+    LLSD defaults = response["defaults"];
 
-    group_datap->mMemberCount = num_members;
-
-    LLSD    member_list = content["members"];
-    LLSD    titles      = content["titles"];
-    LLSD    defaults    = content["defaults"];
-
-    std::string online_status;
-    std::string title;
-    S32         contribution;
-    U64         member_powers;
-    // If this is changed to a bool, make sure to change the LLGroupMemberData constructor
-    bool        is_owner;
+    size_t members_before = group_datap->mMembers.size();
+    size_t members_loaded = members.size();
 
     // Compute this once, rather than every time.
-    U64 default_powers  = llstrtou64(defaults["default_powers"].asString().c_str(), NULL, 16);
+    std::string default_title = titles.size() ? titles[0].asString() : LLStringUtil::null;
+    U64 default_powers = llstrtou64(defaults["default_powers"].asString().c_str(), NULL, 16);
 
-    LLSD::map_const_iterator member_iter_start  = member_list.beginMap();
-    LLSD::map_const_iterator member_iter_end    = member_list.endMap();
-    for( ; member_iter_start != member_iter_end; ++member_iter_start)
+    auto members_end = members.endMap();
+    for (auto it = members.beginMap(); it != members_end; ++it)
     {
         // Reset defaults
-        online_status   = "unknown";
-        title           = titles[0].asString();
-        contribution    = 0;
-        member_powers   = default_powers;
-        is_owner        = false;
+        std::string online_status = "unknown";
+        std::string title = default_title;
+        U64 member_powers = default_powers;
+        S32 donated_square_meters = 0;
+        bool is_owner = false;
 
-        const LLUUID member_id(member_iter_start->first);
-        LLSD member_info = member_iter_start->second;
+        const LLUUID member_id(it->first);
+        LLSD member_info = it->second;
 
-        if(member_info.has("last_login"))
+        if (member_info.has("last_login"))
         {
             online_status = member_info["last_login"].asString();
-            if(online_status == "Online")
-                online_status = LLTrans::getString("group_member_status_online");
-            else
-                formatDateString(online_status);
-        }
-
-        if(member_info.has("title"))
-            title = titles[member_info["title"].asInteger()].asString();
-
-        if(member_info.has("powers"))
-            member_powers = llstrtou64(member_info["powers"].asString().c_str(), NULL, 16);
-
-        if(member_info.has("donated_square_meters"))
-            contribution = member_info["donated_square_meters"];
-
-        if(member_info.has("owner"))
-            is_owner = true;
-
-        LLGroupMemberData* data = new LLGroupMemberData(member_id,
-            contribution,
-            member_powers,
-            title,
-            online_status,
-            is_owner);
-
-        LLGroupMemberData* member_old = group_datap->mMembers[member_id];
-        if (member_old && group_datap->mRoleMemberDataComplete)
-        {
-            LLGroupMemberData::role_list_t::iterator rit = member_old->roleBegin();
-            LLGroupMemberData::role_list_t::iterator end = member_old->roleEnd();
-
-            for ( ; rit != end; ++rit)
+            if (online_status == "Online")
             {
-                data->addRole((*rit).first,(*rit).second);
+                online_status = LLTrans::getString("group_member_status_online");
+            }
+            else
+            {
+                formatDateString(online_status);
             }
         }
-        else
+
+        if (member_info.has("title"))
         {
-            group_datap->mRoleMemberDataComplete = false;
+            title = titles[member_info["title"].asInteger()].asString();
+        }
+
+        if (member_info.has("powers"))
+        {
+            member_powers = llstrtou64(member_info["powers"].asString().c_str(), NULL, 16);
+        }
+
+        if (member_info.has("donated_square_meters"))
+        {
+            donated_square_meters = member_info["donated_square_meters"];
+        }
+
+        if (member_info.has("owner"))
+        {
+            is_owner = true;
+        }
+
+        LLGroupMemberData* data = new LLGroupMemberData(member_id,
+            donated_square_meters, member_powers, title, online_status, is_owner);
+
+        if (group_datap->mRoleMemberDataComplete)
+        {
+            if (LLGroupMemberData* member_old = group_datap->mMembers[member_id])
+            {
+                auto role_end = member_old->roleEnd();
+                for (auto role_it = member_old->roleBegin(); role_it != role_end; ++role_it)
+                {
+                    data->addRole(role_it->first, role_it->second);
+                }
+            }
+            else
+            {
+                group_datap->mRoleMemberDataComplete = false;
+            }
         }
 
         group_datap->mMembers[member_id] = data;
     }
 
+    group_datap->mMemberCount = (S32)group_datap->mMembers.size();
+    group_datap->mMemberDataComplete = true;
+    group_datap->mMemberRequestID.setNull();
     group_datap->mMemberVersion.generate();
 
+    LL_INFOS("GrpMgr") << "members before: " << members_before
+        << ", members loaded: " << members_loaded
+        << ", members now: " << group_datap->mMemberCount << LL_ENDL;
+
     // Technically, we have this data, but to prevent completely overhauling
     // this entire system (it would be nice, but I don't have the time),
     // I'm going to be dumb and just call services I most likely don't need
@@ -2342,12 +2348,16 @@ void LLGroupMgr::processCapGroupMembersRequest(const LLSD& content)
     //
     // TODO:
     // Refactor to reduce multiple calls for data we already have.
-    if(group_datap->mTitles.size() < 1)
+    if (group_datap->mTitles.size() < 1)
+    {
         sendGroupTitlesRequest(group_id);
+    }
 
+    if (page_size && members_loaded >= page_size)
+    {
+        sendCapGroupMembersRequest(group_id, page_size, (U32)group_datap->mMemberCount, sort_column);
+    }
 
-    group_datap->mMemberDataComplete = true;
-    group_datap->mMemberRequestID.setNull();
     // Make the role-member data request
     if (group_datap->mPendingRoleMemberRequest || !group_datap->mRoleMemberDataComplete)
     {
@@ -2357,10 +2367,8 @@ void LLGroupMgr::processCapGroupMembersRequest(const LLSD& content)
 
     group_datap->mChanged = true;
     notifyObservers(GC_MEMBER_DATA);
-
 }
 
-
 void LLGroupMgr::sendGroupRoleChanges(const LLUUID& group_id)
 {
     LL_DEBUGS("GrpMgr") << "LLGroupMgr::sendGroupRoleChanges" << LL_ENDL;
@@ -2379,9 +2387,11 @@ void LLGroupMgr::sendGroupRoleChanges(const LLUUID& group_id)
 void LLGroupMgr::cancelGroupRoleChanges(const LLUUID& group_id)
 {
     LL_DEBUGS("GrpMgr") << "LLGroupMgr::cancelGroupRoleChanges" << LL_ENDL;
-    LLGroupMgrGroupData* group_datap = getGroupData(group_id);
 
-    if (group_datap) group_datap->cancelRoleChanges();
+    if (LLGroupMgrGroupData* group_datap = getGroupData(group_id))
+    {
+        group_datap->cancelRoleChanges();
+    }
 }
 
 //static
@@ -2503,5 +2513,3 @@ void LLGroupMgr::debugClearAllGroups(void*)
     LLGroupMgr::getInstance()->clearGroups();
     LLGroupMgr::parseRoleActions("role_actions.xml");
 }
-
-
diff --git a/indra/newview/llgroupmgr.h b/indra/newview/llgroupmgr.h
index 18efae7654..f96c5ccc14 100644
--- a/indra/newview/llgroupmgr.h
+++ b/indra/newview/llgroupmgr.h
@@ -403,7 +403,7 @@ public:
                                        bool mature_publish);
 
     static void sendGroupMemberJoin(const LLUUID& group_id);
-    static void sendGroupMemberInvites(const LLUUID& group_id, std::map<LLUUID,LLUUID>& role_member_pairs);
+    static void sendGroupMemberInvites(const LLUUID& group_id, std::map<LLUUID, LLUUID>& role_member_pairs);
     static void sendGroupMemberEjects(const LLUUID& group_id,
                                       uuid_vec_t& member_ids);
 
@@ -413,7 +413,8 @@ public:
                                     const uuid_vec_t &ban_list = uuid_vec_t());
 
 
-    void sendCapGroupMembersRequest(const LLUUID& group_id);
+    void sendCapGroupMembersRequest(const LLUUID& group_id,
+        U32 page_size = 0, U32 page_start = 0, const std::string& sort_column = LLStringUtil::null);
 
     void cancelGroupRoleChanges(const LLUUID& group_id);
 
@@ -436,16 +437,15 @@ public:
     void clearGroupData(const LLUUID& group_id);
 
 private:
-    void groupMembersRequestCoro(std::string url, LLUUID groupId);
-    void processCapGroupMembersRequest(const LLSD& content);
+    void groupMembersRequestCoro(std::string url, LLUUID group_id, U32 page_size, U32 page_start, std::string sort_column);
+    void processCapGroupMembersResponse(const LLSD& response, U32 page_size, U32 page_start, const std::string& sort_column);
 
-    void getGroupBanRequestCoro(std::string url, LLUUID groupId);
-    void postGroupBanRequestCoro(std::string url, LLUUID groupId, U32 action, uuid_vec_t banList, bool update);
+    void getGroupBanRequestCoro(std::string url, LLUUID group_id);
+    void postGroupBanRequestCoro(std::string url, LLUUID group_id, U32 action, uuid_vec_t ban_list, bool update);
 
     static void processGroupBanRequest(const LLSD& content);
 
     void notifyObservers(LLGroupChange gc);
-    void notifyObserver(const LLUUID& group_id, LLGroupChange gc);
     void addGroup(LLGroupMgrGroupData* group_datap);
     LLGroupMgrGroupData* createGroupData(const LLUUID &id);
     bool hasPendingPropertyRequest(const LLUUID& id);
@@ -465,7 +465,7 @@ private:
     typedef std::map<LLUUID,observer_set_t> observer_map_t;
     observer_map_t mParticularObservers;
 
-    bool mMemberRequestInFlight;
+    bool mMemberRequestInFlight { false };
 };
 
 
diff --git a/indra/newview/llpanelgroupbulk.cpp b/indra/newview/llpanelgroupbulk.cpp
index f54ec45a3c..433db74cda 100644
--- a/indra/newview/llpanelgroupbulk.cpp
+++ b/indra/newview/llpanelgroupbulk.cpp
@@ -68,33 +68,36 @@ LLPanelGroupBulkImpl::LLPanelGroupBulkImpl(const LLUUID& group_id) :
     mAlreadyInGroup(),
     mConfirmedOwnerInvite(false),
     mListFullNotificationSent(false)
-{}
+{
+}
 
 LLPanelGroupBulkImpl::~LLPanelGroupBulkImpl()
 {
-    if(mAvatarNameCacheConnection.connected())
+    if (mAvatarNameCacheConnection.connected())
     {
         mAvatarNameCacheConnection.disconnect();
     }
 }
 
+// static
 void LLPanelGroupBulkImpl::callbackClickAdd(void* userdata)
 {
-    LLPanelGroupBulk* panelp = (LLPanelGroupBulk*)userdata;
-
-    if(panelp)
+    if (LLPanelGroupBulk* panelp = (LLPanelGroupBulk*)userdata)
     {
-        //Right now this is hard coded with some knowledge that it is part
-        //of a floater since the avatar picker needs to be added as a dependent
-        //floater to the parent floater.
-        //Soon the avatar picker will be embedded into this panel
-        //instead of being it's own separate floater.  But that is next week.
-        //This will do for now. -jwolk May 10, 2006
+        // Right now this is hard coded with some knowledge that it is part
+        // of a floater since the avatar picker needs to be added as a dependent
+        // floater to the parent floater.
+        // Soon the avatar picker will be embedded into this panel
+        // instead of being it's own separate floater.  But that is next week.
+        // This will do for now. -jwolk May 10, 2006
         LLView* button = panelp->findChild<LLButton>("add_button");
         LLFloater* root_floater = gFloaterView->getParentFloater(panelp);
         LLFloaterAvatarPicker* picker = LLFloaterAvatarPicker::show(
-            boost::bind(callbackAddUsers, _1, panelp->mImplementation), true, false, false, root_floater->getName(), button);
-        if(picker)
+            [&](const uuid_vec_t& agent_ids, const std::vector<LLAvatarName>&)
+            {
+                panelp->mImplementation->addUsers(agent_ids);
+            }, true, false, false, root_floater->getName(), button);
+        if (picker)
         {
             root_floater->addDependentFloater(picker);
             LLGroupMgr::getInstance()->sendCapGroupMembersRequest(panelp->mImplementation->mGroupID);
@@ -102,70 +105,72 @@ void LLPanelGroupBulkImpl::callbackClickAdd(void* userdata)
     }
 }
 
+// static
 void LLPanelGroupBulkImpl::callbackClickRemove(void* userdata)
 {
-    LLPanelGroupBulkImpl* selfp = (LLPanelGroupBulkImpl*)userdata;
-    if (selfp)
+    if (LLPanelGroupBulkImpl* selfp = (LLPanelGroupBulkImpl*)userdata)
+    {
         selfp->handleRemove();
+    }
 }
 
+// static
 void LLPanelGroupBulkImpl::callbackClickCancel(void* userdata)
 {
-    LLPanelGroupBulkImpl* selfp = (LLPanelGroupBulkImpl*)userdata;
-    if(selfp)
+    if (LLPanelGroupBulkImpl* selfp = (LLPanelGroupBulkImpl*)userdata)
+    {
         (*(selfp->mCloseCallback))(selfp->mCloseCallbackUserData);
+    }
 }
 
+// static
 void LLPanelGroupBulkImpl::callbackSelect(LLUICtrl* ctrl, void* userdata)
 {
-    LLPanelGroupBulkImpl* selfp = (LLPanelGroupBulkImpl*)userdata;
-    if (selfp)
+    if (LLPanelGroupBulkImpl* selfp = (LLPanelGroupBulkImpl*)userdata)
+    {
         selfp->handleSelection();
+    }
 }
 
-void LLPanelGroupBulkImpl::callbackAddUsers(const uuid_vec_t& agent_ids, void* user_data)
+void LLPanelGroupBulkImpl::addUsers(const uuid_vec_t& agent_ids)
 {
     std::vector<std::string> names;
-    for (S32 i = 0; i < (S32)agent_ids.size(); i++)
+    for (const LLUUID& agent_id : agent_ids)
     {
         LLAvatarName av_name;
-        if (LLAvatarNameCache::get(agent_ids[i], &av_name))
+        if (LLAvatarNameCache::get(agent_id, &av_name))
         {
-            onAvatarNameCache(agent_ids[i], av_name, user_data);
+            onAvatarNameCache(agent_id, av_name);
         }
         else
         {
-            LLPanelGroupBulkImpl* selfp = (LLPanelGroupBulkImpl*) user_data;
-            if (selfp)
+            if (mAvatarNameCacheConnection.connected())
             {
-                if (selfp->mAvatarNameCacheConnection.connected())
-                {
-                    selfp->mAvatarNameCacheConnection.disconnect();
-                }
-                // *TODO : Add a callback per avatar name being fetched.
-                selfp->mAvatarNameCacheConnection = LLAvatarNameCache::get(agent_ids[i],boost::bind(onAvatarNameCache, _1, _2, user_data));
+                mAvatarNameCacheConnection.disconnect();
             }
+            // *TODO : Add a callback per avatar name being fetched.
+            mAvatarNameCacheConnection = LLAvatarNameCache::get(agent_id,
+                [&](const LLUUID& agent_id, const LLAvatarName& av_name)
+                {
+                    onAvatarNameCache(agent_id, av_name);
+                });
         }
     }
 }
 
-void LLPanelGroupBulkImpl::onAvatarNameCache(const LLUUID& agent_id, const LLAvatarName& av_name, void* user_data)
+void LLPanelGroupBulkImpl::onAvatarNameCache(const LLUUID& agent_id, const LLAvatarName& av_name)
 {
-    LLPanelGroupBulkImpl* selfp = (LLPanelGroupBulkImpl*) user_data;
-
-    if (selfp)
+    if (mAvatarNameCacheConnection.connected())
     {
-        if (selfp->mAvatarNameCacheConnection.connected())
-        {
-            selfp->mAvatarNameCacheConnection.disconnect();
-        }
-        std::vector<std::string> names;
-        uuid_vec_t agent_ids;
-        agent_ids.push_back(agent_id);
-        names.push_back(av_name.getCompleteName());
-
-        selfp->addUsers(names, agent_ids);
+        mAvatarNameCacheConnection.disconnect();
     }
+
+    std::vector<std::string> names;
+    uuid_vec_t agent_ids;
+    agent_ids.push_back(agent_id);
+    names.push_back(av_name.getCompleteName());
+
+    addUsers(names, agent_ids);
 }
 
 void LLPanelGroupBulkImpl::handleRemove()
@@ -174,17 +179,15 @@ void LLPanelGroupBulkImpl::handleRemove()
     if (selection.empty())
         return;
 
-    std::vector<LLScrollListItem*>::iterator iter;
-    for(iter = selection.begin(); iter != selection.end(); ++iter)
+    for (const LLScrollListItem* item : selection)
     {
-        mInviteeIDs.erase((*iter)->getUUID());
+        mInviteeIDs.erase(item->getUUID());
     }
 
     mBulkAgentList->deleteSelectedItems();
     mRemoveButton->setEnabled(false);
 
-    if( mOKButton && mOKButton->getEnabled() &&
-        mBulkAgentList->isEmpty())
+    if (mOKButton && mOKButton->getEnabled() && mBulkAgentList->isEmpty())
     {
         mOKButton->setEnabled(false);
     }
@@ -192,24 +195,17 @@ void LLPanelGroupBulkImpl::handleRemove()
 
 void LLPanelGroupBulkImpl::handleSelection()
 {
-    std::vector<LLScrollListItem*> selection = mBulkAgentList->getAllSelected();
-    if (selection.empty())
-        mRemoveButton->setEnabled(false);
-    else
-        mRemoveButton->setEnabled(true);
+    mRemoveButton->setEnabled(mBulkAgentList->getFirstSelected());
 }
 
 void LLPanelGroupBulkImpl::addUsers(const std::vector<std::string>& names, const uuid_vec_t& agent_ids)
 {
-    std::string name;
-    LLUUID id;
-
-    if(mListFullNotificationSent)
+    if (mListFullNotificationSent)
     {
         return;
     }
 
-    if( !mListFullNotificationSent &&
+    if (!mListFullNotificationSent &&
         (names.size() + mInviteeIDs.size() > MAX_GROUP_INVITES))
     {
         mListFullNotificationSent = true;
@@ -223,32 +219,35 @@ void LLPanelGroupBulkImpl::addUsers(const std::vector<std::string>& names, const
 
     for (S32 i = 0; i < (S32)names.size(); ++i)
     {
-        name = names[i];
-        id = agent_ids[i];
+        const LLUUID& id = agent_ids[i];
 
-        if(mInviteeIDs.find(id) != mInviteeIDs.end())
+        if (mInviteeIDs.find(id) != mInviteeIDs.end())
         {
             continue;
         }
 
-        //add the name to the names list
+        // Add the name to the name list
         LLSD row;
         row["id"] = id;
-        row["columns"][0]["value"] = name;
+        row["columns"][0]["value"] = names[i];
 
         mBulkAgentList->addElement(row);
         mInviteeIDs.insert(id);
 
         // We've successfully added someone to the list.
-        if(mOKButton && !mOKButton->getEnabled())
+        if (mOKButton && !mOKButton->getEnabled())
+        {
             mOKButton->setEnabled(true);
+        }
     }
 }
 
 void LLPanelGroupBulkImpl::setGroupName(std::string name)
 {
-    if(mGroupName)
+    if (mGroupName)
+    {
         mGroupName->setText(name);
+    }
 }
 
 
@@ -258,7 +257,8 @@ LLPanelGroupBulk::LLPanelGroupBulk(const LLUUID& group_id) :
     mPendingGroupPropertiesUpdate(false),
     mPendingRoleDataUpdate(false),
     mPendingMemberDataUpdate(false)
-{}
+{
+}
 
 LLPanelGroupBulk::~LLPanelGroupBulk()
 {
@@ -269,11 +269,15 @@ void LLPanelGroupBulk::clear()
 {
     mImplementation->mInviteeIDs.clear();
 
-    if(mImplementation->mBulkAgentList)
+    if (mImplementation->mBulkAgentList)
+    {
         mImplementation->mBulkAgentList->deleteAllItems();
+    }
 
-    if(mImplementation->mOKButton)
+    if (mImplementation->mOKButton)
+    {
         mImplementation->mOKButton->setEnabled(false);
+    }
 }
 
 void LLPanelGroupBulk::update()
@@ -292,12 +296,14 @@ void LLPanelGroupBulk::updateGroupName()
 {
     LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mImplementation->mGroupID);
 
-    if( gdatap &&
+    if (gdatap &&
         gdatap->isGroupPropertiesDataComplete())
     {
         // Only do work if the current group name differs
-        if(mImplementation->mGroupName->getText().compare(gdatap->mName) != 0)
+        if (mImplementation->mGroupName->getText().compare(gdatap->mName) != 0)
+        {
             mImplementation->setGroupName(gdatap->mName);
+        }
     }
     else
     {
@@ -308,43 +314,34 @@ void LLPanelGroupBulk::updateGroupName()
 void LLPanelGroupBulk::updateGroupData()
 {
     LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mImplementation->mGroupID);
-    if(gdatap && gdatap->isGroupPropertiesDataComplete())
+    if (gdatap && gdatap->isGroupPropertiesDataComplete())
     {
         mPendingGroupPropertiesUpdate = false;
     }
-    else
+    else if (!mPendingGroupPropertiesUpdate)
     {
-        if(!mPendingGroupPropertiesUpdate)
-        {
-            mPendingGroupPropertiesUpdate = true;
-            LLGroupMgr::getInstance()->sendGroupPropertiesRequest(mImplementation->mGroupID);
-        }
+        mPendingGroupPropertiesUpdate = true;
+        LLGroupMgr::getInstance()->sendGroupPropertiesRequest(mImplementation->mGroupID);
     }
 
-    if(gdatap && gdatap->isRoleDataComplete())
+    if (gdatap && gdatap->isRoleDataComplete())
     {
         mPendingRoleDataUpdate = false;
     }
-    else
+    else if (!mPendingRoleDataUpdate)
     {
-        if(!mPendingRoleDataUpdate)
-        {
-            mPendingRoleDataUpdate = true;
-            LLGroupMgr::getInstance()->sendGroupRoleDataRequest(mImplementation->mGroupID);
-        }
+        mPendingRoleDataUpdate = true;
+        LLGroupMgr::getInstance()->sendGroupRoleDataRequest(mImplementation->mGroupID);
     }
 
-    if(gdatap && gdatap->isMemberDataComplete())
+    if (gdatap && gdatap->isMemberDataComplete())
     {
         mPendingMemberDataUpdate = false;
     }
-    else
+    else if (!mPendingMemberDataUpdate)
     {
-        if(!mPendingMemberDataUpdate)
-        {
-            mPendingMemberDataUpdate = true;
-            LLGroupMgr::getInstance()->sendCapGroupMembersRequest(mImplementation->mGroupID);
-        }
+        mPendingMemberDataUpdate = true;
+        LLGroupMgr::getInstance()->sendCapGroupMembersRequest(mImplementation->mGroupID);
     }
 }
 
@@ -367,21 +364,20 @@ void LLPanelGroupBulk::setCloseCallback(void (*close_callback)(void*), void* dat
 void LLPanelGroupBulk::addUsers(uuid_vec_t& agent_ids)
 {
     std::vector<std::string> names;
-    for (S32 i = 0; i < (S32)agent_ids.size(); i++)
+    for (size_t i = 0; i < agent_ids.size(); i++)
     {
         std::string fullname;
-        LLUUID agent_id = agent_ids[i];
+        const LLUUID& agent_id = agent_ids[i];
         LLViewerObject* dest = gObjectList.findObject(agent_id);
-        if(dest && dest->isAvatar())
+        if (dest && dest->isAvatar())
         {
             LLNameValue* nvfirst = dest->getNVPair("FirstName");
             LLNameValue* nvlast = dest->getNVPair("LastName");
-            if(nvfirst && nvlast)
+            if (nvfirst && nvlast)
             {
-                fullname = LLCacheName::buildFullName(
-                    nvfirst->getString(), nvlast->getString());
-
+                fullname = LLCacheName::buildFullName(nvfirst->getString(), nvlast->getString());
             }
+
             if (!fullname.empty())
             {
                 names.push_back(fullname);
@@ -394,20 +390,25 @@ void LLPanelGroupBulk::addUsers(uuid_vec_t& agent_ids)
         }
         else
         {
-            //looks like user try to invite offline friend
-            //for offline avatar_id gObjectList.findObject() will return null
-            //so we need to do this additional search in avatar tracker, see EXT-4732
+            // Looks like the user tries to invite a friend which is offline.
+            // For offline avatar_id gObjectList.findObject() will return null
+            // so we need to do this additional search in avatar tracker, see EXT-4732
             if (LLAvatarTracker::instance().isBuddy(agent_id))
             {
                 LLAvatarName av_name;
                 if (!LLAvatarNameCache::get(agent_id, &av_name))
                 {
-                    // actually it should happen, just in case
-                    LLAvatarNameCache::get(LLUUID(agent_id), boost::bind(&LLPanelGroupBulk::addUserCallback, this, _1, _2));
+                    // Actually it shouldn't happen, just in case
+                    LLAvatarNameCache::get(LLUUID(agent_id),
+                        [&](const LLUUID& agent_id, const LLAvatarName& av_name)
+                        {
+                            addUserCallback(agent_id, av_name);
+                        });
                     // for this special case!
-                    //when there is no cached name we should remove resident from agent_ids list to avoid breaking of sequence
+                    // when there is no cached name we should remove resident from agent_ids list to avoid breaking of sequence
                     // removed id will be added in callback
                     agent_ids.erase(agent_ids.begin() + i);
+                    i--; // To process the next agent_id with the same index
                 }
                 else
                 {
diff --git a/indra/newview/llpanelgroupbulkimpl.h b/indra/newview/llpanelgroupbulkimpl.h
index 963780200a..5a479f8117 100644
--- a/indra/newview/llpanelgroupbulkimpl.h
+++ b/indra/newview/llpanelgroupbulkimpl.h
@@ -50,9 +50,10 @@ public:
     static void callbackClickCancel(void* userdata);
 
     static void callbackSelect(LLUICtrl* ctrl, void* userdata);
-    static void callbackAddUsers(const uuid_vec_t& agent_ids, void* user_data);
 
-    static void onAvatarNameCache(const LLUUID& agent_id, const LLAvatarName& av_name, void* user_data);
+    void addUsers(const uuid_vec_t& agent_ids);
+
+    void onAvatarNameCache(const LLUUID& agent_id, const LLAvatarName& av_name);
 
     void handleRemove();
     void handleSelection();
diff --git a/indra/newview/llpanelgrouproles.cpp b/indra/newview/llpanelgrouproles.cpp
index bc56b49e5d..864d73683e 100644
--- a/indra/newview/llpanelgrouproles.cpp
+++ b/indra/newview/llpanelgrouproles.cpp
@@ -812,20 +812,14 @@ bool LLPanelGroupMembersSubTab::postBuildSubTab(LLView* root)
 {
     LLPanelGroupSubTab::postBuildSubTab(root);
 
-    // Upcast parent so we can ask it for sibling controls.
-    LLPanelGroupRoles* parent = (LLPanelGroupRoles*) root;
-
     // Look recursively from the parent to find all our widgets.
-    bool recurse = true;
-    mHeader = parent->findChild<LLPanel>("members_header", recurse);
-    mFooter = parent->findChild<LLPanel>("members_footer", recurse);
+    mHeader = root->findChild<LLPanel>("members_header");
+    mFooter = root->findChild<LLPanel>("members_footer");
 
-    mMembersList        = parent->getChild<LLNameListCtrl>("member_list", recurse);
-    mAssignedRolesList  = parent->getChild<LLScrollListCtrl>("member_assigned_roles", recurse);
-    mAllowedActionsList = parent->getChild<LLScrollListCtrl>("member_allowed_actions", recurse);
-    mActionDescription = parent->getChild<LLTextEditor>("member_action_description", recurse);
-
-    if (!mMembersList || !mAssignedRolesList || !mAllowedActionsList || !mActionDescription) return false;
+    mMembersList = root->getChild<LLNameListCtrl>("member_list");
+    mAssignedRolesList = root->getChild<LLScrollListCtrl>("member_assigned_roles");
+    mAllowedActionsList = root->getChild<LLScrollListCtrl>("member_allowed_actions");
+    mActionDescription = root->getChild<LLTextEditor>("member_action_description");
 
     mAllowedActionsList->setCommitOnSelectionChange(true);
     mAllowedActionsList->setCommitCallback(boost::bind(&LLPanelGroupMembersSubTab::updateActionDescription, this));
@@ -844,31 +838,22 @@ bool LLPanelGroupMembersSubTab::postBuildSubTab(LLView* root)
     row["columns"][2]["column"] = "online";
     mMembersList->addElement(row);
     std::string order_by = gSavedSettings.getString("GroupMembersSortOrder");
-    if(!order_by.empty())
+    if (!order_by.empty())
     {
         mMembersList->sortByColumn(order_by, true);
     }
 
-    LLButton* button = parent->getChild<LLButton>("member_invite", recurse);
-    if ( button )
-    {
-        button->setClickedCallback(onInviteMember, this);
-        button->setEnabled(gAgent.hasPowerInGroup(mGroupID, GP_MEMBER_INVITE));
-    }
+    LLButton* button = root->getChild<LLButton>("member_invite");
+    button->setClickedCallback(onInviteMember, this);
+    button->setEnabled(gAgent.hasPowerInGroup(mGroupID, GP_MEMBER_INVITE));
 
-    mEjectBtn = parent->getChild<LLButton>("member_eject", recurse);
-    if ( mEjectBtn )
-    {
-        mEjectBtn->setClickedCallback(onEjectMembers, this);
-        mEjectBtn->setEnabled(false);
-    }
+    mEjectBtn = root->getChild<LLButton>("member_eject");
+    mEjectBtn->setClickedCallback(onEjectMembers, this);
+    mEjectBtn->setEnabled(false);
 
-    mBanBtn = parent->getChild<LLButton>("member_ban", recurse);
-    if(mBanBtn)
-    {
-        mBanBtn->setClickedCallback(onBanMember, this);
-        mBanBtn->setEnabled(false);
-    }
+    mBanBtn = root->getChild<LLButton>("member_ban");
+    mBanBtn->setClickedCallback(onBanMember, this);
+    mBanBtn->setEnabled(false);
 
     return true;
 }
@@ -1371,11 +1356,13 @@ void LLPanelGroupMembersSubTab::activate()
     LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
 
     LLPanelGroupSubTab::activate();
-    if(!mActivated)
+    if (!mActivated)
     {
         if (!gdatap || !gdatap->isMemberDataComplete())
         {
-            LLGroupMgr::getInstance()->sendCapGroupMembersRequest(mGroupID);
+            const U32 page_size = 50;
+            std::string sort_column = mMembersList->getSortColumnName();
+            LLGroupMgr::getInstance()->sendCapGroupMembersRequest(mGroupID, page_size, 0, sort_column);
         }
 
         if (!gdatap || !gdatap->isRoleMemberDataComplete())
@@ -1483,8 +1470,7 @@ bool LLPanelGroupMembersSubTab::addOwnerCB(const LLSD& notification, const LLSD&
 
 void LLPanelGroupMembersSubTab::applyMemberChanges()
 {
-    //sucks to do a find again here, but it is in constant time, so, could
-    //be worse
+    // Sucks to do a find again here, but it is in constant time, so, could be worse
     LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
     if (!gdatap)
     {
@@ -1492,8 +1478,7 @@ void LLPanelGroupMembersSubTab::applyMemberChanges()
         return;
     }
 
-    //we need to add all of the changed roles data
-    //for each member whose role changed
+    // We need to add all of the changed roles data for each member whose role changed
     for (member_role_changes_map_t::iterator member = mMemberRoleChangeData.begin();
          member != mMemberRoleChangeData.end(); ++member)
     {
@@ -1511,7 +1496,7 @@ void LLPanelGroupMembersSubTab::applyMemberChanges()
     mMemberRoleChangeData.clear();
 
     LLGroupMgr::getInstance()->sendGroupRoleMemberChanges(mGroupID);
-    //force a UI update
+    // Force an UI update
     handleMemberSelect();
 
     mChanged = false;
@@ -1522,32 +1507,23 @@ void LLPanelGroupMembersSubTab::applyMemberChanges()
 bool LLPanelGroupMembersSubTab::matchesSearchFilter(const std::string& fullname)
 {
     // If the search filter is empty, everything passes.
-    if (mSearchFilter.empty()) return true;
+    if (mSearchFilter.empty())
+        return true;
 
     // Create a full name, and compare it to the search filter.
     std::string fullname_lc(fullname);
     LLStringUtil::toLower(fullname_lc);
 
     std::string::size_type match = fullname_lc.find(mSearchFilter);
-
-    if (std::string::npos == match)
-    {
-        // not found
-        return false;
-    }
-    else
-    {
-        return true;
-    }
+    return match != std::string::npos;
 }
 
 U64 LLPanelGroupMembersSubTab::getAgentPowersBasedOnRoleChanges(const LLUUID& agent_id)
 {
-    //we loop over all of the changes
-    //if we are adding a role, then we simply add the role's powers
-    //if we are removing a role, we store that role id away
-    //and then we have to build the powers up bases on the roles the agent
-    //is in
+    // We loop over all of the changes
+    // If we are adding a role, then we simply add the role's powers
+    // If we are removing a role, we store that role id away
+    // and then we have to build the powers up bases on the roles the agent is in
 
     LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
     if (!gdatap)
@@ -1557,7 +1533,7 @@ U64 LLPanelGroupMembersSubTab::getAgentPowersBasedOnRoleChanges(const LLUUID& ag
     }
 
     LLGroupMgrGroupData::member_list_t::iterator iter = gdatap->mMembers.find(agent_id);
-    if ( iter == gdatap->mMembers.end() )
+    if (iter == gdatap->mMembers.end())
     {
         LL_WARNS() << "LLPanelGroupMembersSubTab::getAgentPowersBasedOnRoleChanges() -- No member data for member with UUID " << agent_id << LL_ENDL;
         return GP_NO_POWERS;
@@ -1570,37 +1546,36 @@ U64 LLPanelGroupMembersSubTab::getAgentPowersBasedOnRoleChanges(const LLUUID& ag
         return GP_NO_POWERS;
     }
 
-    //see if there are unsaved role changes for this agent
+    // See if there are unsaved role changes for this agent
     role_change_data_map_t* role_change_datap = NULL;
     member_role_changes_map_t::iterator member = mMemberRoleChangeData.find(agent_id);
-    if ( member != mMemberRoleChangeData.end() )
+    if (member != mMemberRoleChangeData.end())
     {
-        //this member has unsaved role changes
-        //so grab them
-        role_change_datap = (*member).second;
+        // This member has unsaved role changes
+        // so grab them
+        role_change_datap = member->second;
     }
 
     U64 new_powers = GP_NO_POWERS;
 
-    if ( role_change_datap )
+    if (role_change_datap)
     {
         uuid_vec_t roles_to_be_removed;
 
-        for (role_change_data_map_t::iterator role = role_change_datap->begin();
-             role != role_change_datap->end(); ++ role)
+        for (const auto& role : *role_change_datap)
         {
-            if ( role->second == RMC_ADD )
+            if (role.second == RMC_ADD)
             {
-                new_powers |= gdatap->getRolePowers(role->first);
+                new_powers |= gdatap->getRolePowers(role.first);
             }
             else
             {
-                roles_to_be_removed.push_back(role->first);
+                roles_to_be_removed.push_back(role.first);
             }
         }
 
-        //loop over the member's current roles, summing up
-        //the powers (not including the role we are removing)
+        // loop over the member's current roles, summing up
+        // the powers (not including the role we are removing)
         for (LLGroupMemberData::role_list_t::iterator current_role = member_data->roleBegin();
              current_role != member_data->roleEnd(); ++current_role)
         {
@@ -1661,9 +1636,10 @@ void LLPanelGroupMembersSubTab::draw()
 
 void LLPanelGroupMembersSubTab::update(LLGroupChange gc)
 {
-    if (mGroupID.isNull()) return;
+    if (mGroupID.isNull())
+        return;
 
-    if ( GC_TITLES == gc || GC_PROPERTIES == gc )
+    if (GC_TITLES == gc || GC_PROPERTIES == gc)
     {
         // Don't care about title or general group properties updates.
         return;
@@ -1677,9 +1653,9 @@ void LLPanelGroupMembersSubTab::update(LLGroupChange gc)
     }
 
     // Wait for both all data to be retrieved before displaying anything.
-    if (   gdatap->isMemberDataComplete()
-        && gdatap->isRoleDataComplete()
-        && gdatap->isRoleMemberDataComplete())
+    if (gdatap->isMemberDataComplete() &&
+        gdatap->isRoleDataComplete() &&
+        gdatap->isRoleMemberDataComplete())
     {
         mMemberProgress = gdatap->mMembers.begin();
         mPendingMemberUpdate = true;
@@ -1690,18 +1666,18 @@ void LLPanelGroupMembersSubTab::update(LLGroupChange gc)
         // Build a string with info on retrieval progress.
         std::ostringstream retrieved;
 
-        if ( gdatap->isRoleDataComplete() && gdatap->isMemberDataComplete() && !gdatap->mMembers.size() )
+        if (gdatap->isRoleDataComplete() && gdatap->isMemberDataComplete() && !gdatap->mMembers.size())
         {
             // MAINT-5237
             retrieved << "Member list not available.";
         }
-        else if ( !gdatap->isMemberDataComplete() )
+        else if (!gdatap->isMemberDataComplete())
         {
             // Still busy retreiving member list.
             retrieved << "Retrieving member list (" << gdatap->mMembers.size()
                       << " / " << gdatap->mMemberCount << ")...";
         }
-        else if( !gdatap->isRoleDataComplete() )
+        else if (!gdatap->isRoleDataComplete())
         {
             // Still busy retreiving role list.
             retrieved << "Retrieving role list (" << gdatap->mRoles.size()
@@ -1719,7 +1695,9 @@ void LLPanelGroupMembersSubTab::update(LLGroupChange gc)
 
 void LLPanelGroupMembersSubTab::addMemberToList(LLGroupMemberData* data)
 {
-    if (!data) return;
+    if (!data)
+        return;
+
     LLUIString donated = getString("donation_area");
     donated.setArg("[AREA]", llformat("%d", data->getContribution()));
 
@@ -1765,7 +1743,7 @@ void LLPanelGroupMembersSubTab::onNameCache(const LLUUID& update_id, LLGroupMemb
     if (matchesSearchFilter(av_name.getAccountName()))
     {
         addMemberToList(member);
-        if(!mMembersList->getEnabled())
+        if (!mMembersList->getEnabled())
         {
             mMembersList->setEnabled(true);
         }
@@ -1788,15 +1766,15 @@ void LLPanelGroupMembersSubTab::updateMembers()
 
     // Make sure all data is still complete.  Incomplete data
     // may occur if we refresh.
-    if (   !gdatap->isMemberDataComplete()
-        || !gdatap->isRoleDataComplete()
-        || !gdatap->isRoleMemberDataComplete())
+    if (!gdatap->isMemberDataComplete() ||
+        !gdatap->isRoleDataComplete() ||
+        !gdatap->isRoleMemberDataComplete())
     {
         return;
     }
 
-    //cleanup list only for first iteration
-    if(mMemberProgress == gdatap->mMembers.begin())
+    // Cleanup list only for first iteration
+    if (mMemberProgress == gdatap->mMembers.begin())
     {
         mMembersList->deleteAllItems();
     }
@@ -1806,7 +1784,7 @@ void LLPanelGroupMembersSubTab::updateMembers()
     LLTimer update_time;
     update_time.setTimerExpirySec(UPDATE_MEMBERS_SECONDS_PER_FRAME);
 
-    for( ; mMemberProgress != end && !update_time.hasExpired(); ++mMemberProgress)
+    for (; mMemberProgress != end && !update_time.hasExpired(); ++mMemberProgress)
     {
         if (!mMemberProgress->second)
             continue;
@@ -1866,7 +1844,8 @@ void LLPanelGroupMembersSubTab::onBanMember(void* user_data)
 void LLPanelGroupMembersSubTab::confirmBanMembers()
 {
     std::vector<LLScrollListItem*> selection = mMembersList->getAllSelected();
-    if (selection.empty()) return;
+    if (selection.empty())
+        return;
 
     auto selection_count = selection.size();
     if (selection_count == 1)
@@ -1912,8 +1891,7 @@ void LLPanelGroupMembersSubTab::updateActionDescription()
         return;
     }
 
-    LLRoleAction* rap = (LLRoleAction*)action_item->getUserdata();
-    if (rap)
+    if (LLRoleAction* rap = (LLRoleAction*)action_item->getUserdata())
     {
         std::string desc = rap->mLongDescription.empty() ? rap->mDescription : rap->mLongDescription;
         mActionDescription->setText(desc);
@@ -1923,23 +1901,22 @@ void LLPanelGroupMembersSubTab::updateActionDescription()
 void LLPanelGroupMembersSubTab::handleBanMember()
 {
     LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
-    if(!gdatap)
+    if (!gdatap)
     {
         LL_WARNS("Groups") << "Unable to get group data for group " << mGroupID << LL_ENDL;
         return;
     }
 
     std::vector<LLScrollListItem*> selection = mMembersList->getAllSelected();
-    if(selection.empty())
+    if (selection.empty())
     {
         return;
     }
 
     uuid_vec_t ban_ids;
-    std::vector<LLScrollListItem*>::iterator itor;
-    for(itor = selection.begin(); itor != selection.end(); ++itor)
+    for (const LLScrollListItem* item : selection)
     {
-        LLUUID ban_id = (*itor)->getUUID();
+        LLUUID ban_id = item->getUUID();
         ban_ids.push_back(ban_id);
 
         LLGroupBanData ban_data;
@@ -1983,54 +1960,33 @@ bool LLPanelGroupRolesSubTab::postBuildSubTab(LLView* root)
     LLPanelGroupRoles* parent = (LLPanelGroupRoles*) root;
 
     // Look recursively from the parent to find all our widgets.
-    bool recurse = true;
-    mHeader = parent->findChild<LLPanel>("roles_header", recurse);
-    mFooter = parent->findChild<LLPanel>("roles_footer", recurse);
+    mHeader = parent->findChild<LLPanel>("roles_header");
+    mFooter = parent->findChild<LLPanel>("roles_footer");
 
+    mRolesList = parent->getChild<LLScrollListCtrl>("role_list");
+    mAssignedMembersList = parent->getChild<LLNameListCtrl>("role_assigned_members");
+    mAllowedActionsList = parent->getChild<LLScrollListCtrl>("role_allowed_actions");
+    mActionDescription  = parent->getChild<LLTextEditor>("role_action_description");
 
-    mRolesList      = parent->getChild<LLScrollListCtrl>("role_list", recurse);
-    mAssignedMembersList    = parent->getChild<LLNameListCtrl>("role_assigned_members", recurse);
-    mAllowedActionsList = parent->getChild<LLScrollListCtrl>("role_allowed_actions", recurse);
-    mActionDescription  = parent->getChild<LLTextEditor>("role_action_description", recurse);
+    mRoleName = parent->getChild<LLLineEditor>("role_name");
+    mRoleTitle = parent->getChild<LLLineEditor>("role_title");
+    mRoleDescription = parent->getChild<LLTextEditor>("role_description");
 
-    mRoleName = parent->getChild<LLLineEditor>("role_name", recurse);
-    mRoleTitle = parent->getChild<LLLineEditor>("role_title", recurse);
-    mRoleDescription = parent->getChild<LLTextEditor>("role_description", recurse);
-
-    mMemberVisibleCheck = parent->getChild<LLCheckBoxCtrl>("role_visible_in_list", recurse);
-
-    if (!mRolesList || !mAssignedMembersList || !mAllowedActionsList || !mActionDescription
-        || !mRoleName || !mRoleTitle || !mRoleDescription || !mMemberVisibleCheck)
-    {
-        LL_WARNS() << "ARG! element not found." << LL_ENDL;
-        return false;
-    }
+    mMemberVisibleCheck = parent->getChild<LLCheckBoxCtrl>("role_visible_in_list");
 
     mRemoveEveryoneTxt = getString("cant_delete_role");
 
-    mCreateRoleButton =
-        parent->getChild<LLButton>("role_create", recurse);
-    if ( mCreateRoleButton )
-    {
-        mCreateRoleButton->setClickedCallback(onCreateRole, this);
-        mCreateRoleButton->setEnabled(false);
-    }
+    mCreateRoleButton = parent->getChild<LLButton>("role_create");
+    mCreateRoleButton->setClickedCallback(onCreateRole, this);
+    mCreateRoleButton->setEnabled(false);
 
-    mCopyRoleButton =
-        parent->getChild<LLButton>("role_copy", recurse);
-    if ( mCopyRoleButton )
-    {
-        mCopyRoleButton->setClickedCallback(onCopyRole, this);
-        mCopyRoleButton->setEnabled(false);
-    }
+    mCopyRoleButton = parent->getChild<LLButton>("role_copy");
+    mCopyRoleButton->setClickedCallback(onCopyRole, this);
+    mCopyRoleButton->setEnabled(false);
 
-    mDeleteRoleButton =
-        parent->getChild<LLButton>("role_delete", recurse);
-    if ( mDeleteRoleButton )
-    {
-        mDeleteRoleButton->setClickedCallback(onDeleteRole, this);
-        mDeleteRoleButton->setEnabled(false);
-    }
+    mDeleteRoleButton = parent->getChild<LLButton>("role_delete");
+    mDeleteRoleButton->setClickedCallback(onDeleteRole, this);
+    mDeleteRoleButton->setEnabled(false);
 
     mRolesList->setCommitOnSelectionChange(true);
     mRolesList->setCommitCallback(onRoleSelect, this);
@@ -2949,26 +2905,19 @@ void LLPanelGroupActionsSubTab::handleActionSelect()
     mActionMembers->deleteAllItems();
     mActionRoles->deleteAllItems();
 
+    std::vector<LLScrollListItem*> selection = mActionList->getAllSelected();
+    if (selection.empty())
+        return;
+
     U64 power_mask = GP_NO_POWERS;
-    std::vector<LLScrollListItem*> selection =
-                            mActionList->getAllSelected();
-    if (selection.empty()) return;
-
-    LLRoleAction* rap;
-
-    std::vector<LLScrollListItem*>::iterator itor;
-    for (itor = selection.begin() ;
-         itor != selection.end(); ++itor)
+    for (const LLScrollListItem* item : selection)
     {
-        rap = (LLRoleAction*)( (*itor)->getUserdata() );
-        power_mask |= rap->mPowerBit;
+        power_mask |= ((LLRoleAction*)item->getUserdata())->mPowerBit;
     }
 
     if (selection.size() == 1)
     {
-        LLScrollListItem* item = selection[0];
-        rap = (LLRoleAction*)(item->getUserdata());
-
+        LLRoleAction* rap = (LLRoleAction*)selection.front()->getUserdata();
         if (rap->mLongDescription.empty())
         {
             mActionDescription->setText(rap->mDescription);
@@ -2985,21 +2934,19 @@ void LLPanelGroupActionsSubTab::handleActionSelect()
 
     LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
 
-    if (!gdatap) return;
+    if (!gdatap)
+        return;
 
     if (gdatap->isMemberDataComplete())
     {
-        LLGroupMgrGroupData::member_list_t::iterator it = gdatap->mMembers.begin();
-        LLGroupMgrGroupData::member_list_t::iterator end = gdatap->mMembers.end();
-        LLGroupMemberData* gmd;
-
-        for ( ; it != end; ++it)
+        for (const auto& it : gdatap->mMembers)
         {
-            gmd = (*it).second;
-            if (!gmd) continue;
-            if ((gmd->getAgentPowers() & power_mask) == power_mask)
+            if (LLGroupMemberData* gmd = it.second)
             {
-                mActionMembers->addNameItem(gmd->getID());
+                if ((gmd->getAgentPowers() & power_mask) == power_mask)
+                {
+                    mActionMembers->addNameItem(gmd->getID());
+                }
             }
         }
     }

From 603f448393d43cb1fc67083b40c950a1d03fa4a6 Mon Sep 17 00:00:00 2001
From: Alexander Gavriliuk <alexandrgproductengine@lindenlab.com>
Date: Wed, 24 Jul 2024 17:15:07 +0200
Subject: [PATCH 05/30] #2095 Crash #1497728:
 LLInventorySingleFolderPanel::hasVisibleItems

---
 indra/newview/llinventorypanel.cpp | 17 +++++++++++------
 indra/newview/llinventorypanel.h   |  6 +++---
 2 files changed, 14 insertions(+), 9 deletions(-)

diff --git a/indra/newview/llinventorypanel.cpp b/indra/newview/llinventorypanel.cpp
index 1a6e25fb0f..9e4f4c0adc 100644
--- a/indra/newview/llinventorypanel.cpp
+++ b/indra/newview/llinventorypanel.cpp
@@ -2334,14 +2334,14 @@ void LLInventorySingleFolderPanel::clearNavigationHistory()
     mBackwardFolders.clear();
 }
 
-bool LLInventorySingleFolderPanel::isBackwardAvailable()
+bool LLInventorySingleFolderPanel::isBackwardAvailable() const
 {
-    return (!mBackwardFolders.empty() && (mFolderID != mBackwardFolders.back()));
+    return !mBackwardFolders.empty() && (mFolderID != mBackwardFolders.back());
 }
 
-bool LLInventorySingleFolderPanel::isForwardAvailable()
+bool LLInventorySingleFolderPanel::isForwardAvailable() const
 {
-    return (!mForwardFolders.empty() && (mFolderID != mForwardFolders.back()));
+    return !mForwardFolders.empty() && (mFolderID != mForwardFolders.back());
 }
 
 boost::signals2::connection LLInventorySingleFolderPanel::setRootChangedCallback(root_changed_callback_t cb)
@@ -2406,9 +2406,14 @@ void LLInventorySingleFolderPanel::updateSingleFolderRoot()
     }
 }
 
-bool LLInventorySingleFolderPanel::hasVisibleItems()
+bool LLInventorySingleFolderPanel::hasVisibleItems() const
 {
-    return mFolderRoot.get()->hasVisibleChildren();
+    if (const LLFolderView* root = mFolderRoot.get())
+    {
+        return root->hasVisibleChildren();
+    }
+
+    return false;
 }
 
 void LLInventorySingleFolderPanel::doCreate(const LLSD& userdata)
diff --git a/indra/newview/llinventorypanel.h b/indra/newview/llinventorypanel.h
index 6dead2cf6d..56909c8d98 100644
--- a/indra/newview/llinventorypanel.h
+++ b/indra/newview/llinventorypanel.h
@@ -420,10 +420,10 @@ public:
     void doToSelected(const LLSD& userdata);
     void doShare();
 
-    bool isBackwardAvailable();
-    bool isForwardAvailable();
+    bool isBackwardAvailable() const;
+    bool isForwardAvailable() const;
 
-    bool hasVisibleItems();
+    bool hasVisibleItems() const;
 
     void setNavBackwardList(std::list<LLUUID> backward_list) { mBackwardFolders = backward_list; }
     void setNavForwardList(std::list<LLUUID> forward_list) { mForwardFolders = forward_list; }

From df459684d430910e44ddb1abc6f231c6d460442f Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Wed, 24 Jul 2024 15:02:09 -0400
Subject: [PATCH 06/30] Fix warning/misnamed button image
 PushButton_Disabled_Selected to PushButton_Selected_Disabled

---
 indra/newview/skins/default/xui/en/panel_scrolling_param.xml | 4 ++--
 indra/newview/skins/default/xui/en/widgets/drop_down.xml     | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/indra/newview/skins/default/xui/en/panel_scrolling_param.xml b/indra/newview/skins/default/xui/en/panel_scrolling_param.xml
index 2035bc2caa..ec642131ae 100644
--- a/indra/newview/skins/default/xui/en/panel_scrolling_param.xml
+++ b/indra/newview/skins/default/xui/en/panel_scrolling_param.xml
@@ -84,7 +84,7 @@
      enabled="false"
      height="132"
      image_disabled="PushButton_Disabled"
-     image_disabled_selected="PushButton_Disabled_Selected"
+     image_disabled_selected="PushButton_Selected_Disabled"
      image_selected="PushButton_Selected"
      image_unselected="PushButton_Off"
      layout="topleft"
@@ -97,7 +97,7 @@
      enabled="false"
      height="132"
      image_disabled="PushButton_Disabled"
-     image_disabled_selected="PushButton_Disabled_Selected"
+     image_disabled_selected="PushButton_Selected_Disabled"
      image_selected="PushButton_Selected"
      image_unselected="PushButton_Off"
      layout="topleft"
diff --git a/indra/newview/skins/default/xui/en/widgets/drop_down.xml b/indra/newview/skins/default/xui/en/widgets/drop_down.xml
index 75ed485645..80f98b64fc 100644
--- a/indra/newview/skins/default/xui/en/widgets/drop_down.xml
+++ b/indra/newview/skins/default/xui/en/widgets/drop_down.xml
@@ -12,7 +12,7 @@
                           image_unselected="PushButton_Off"
                           image_selected="PushButton_Selected"
                           image_disabled="PushButton_Disabled"
-                          image_disabled_selected="PushButton_Disabled_Selected"
+                          image_disabled_selected="PushButton_Selected_Disabled"
                           image_overlay="Combobox_Over"
                           image_overlay_alignment="right" />
   <drop_down.combo_list bg_writeable_color="white" />

From 4b543b618b101aca9dee1f224d8dbd4fbf937d71 Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Wed, 24 Jul 2024 15:05:08 -0400
Subject: [PATCH 07/30] Cache more frequently accessed settings

---
 indra/newview/llhudtext.cpp        |  3 ++-
 indra/newview/llmeshrepository.cpp |  3 ++-
 indra/newview/lloutfitgallery.cpp  |  3 ++-
 indra/newview/llphysicsmotion.cpp  | 33 +++++++++++++++---------------
 indra/newview/lltoolpie.cpp        |  3 ++-
 5 files changed, 25 insertions(+), 20 deletions(-)

diff --git a/indra/newview/llhudtext.cpp b/indra/newview/llhudtext.cpp
index 5ee0ab437d..78afe43ffe 100644
--- a/indra/newview/llhudtext.cpp
+++ b/indra/newview/llhudtext.cpp
@@ -392,7 +392,8 @@ void LLHUDText::updateVisibility()
 
     LLVector3 pos_agent_center = gAgent.getPosAgentFromGlobal(mPositionGlobal) - dir_from_camera;
     F32 last_distance_center = (pos_agent_center - LLViewerCamera::getInstance()->getOrigin()).magVec();
-    F32 max_draw_distance = gSavedSettings.getF32("PrimTextMaxDrawDistance");
+    static LLCachedControl<bool> prim_text_max_dist(gSavedSettings, "PrimTextMaxDrawDistance");
+    F32 max_draw_distance = prim_text_max_dist;
 
     if(max_draw_distance < 0)
     {
diff --git a/indra/newview/llmeshrepository.cpp b/indra/newview/llmeshrepository.cpp
index c02a12e6b2..1c64ed6822 100644
--- a/indra/newview/llmeshrepository.cpp
+++ b/indra/newview/llmeshrepository.cpp
@@ -3743,7 +3743,8 @@ void LLMeshRepository::notifyLoadedMeshes()
               ? (2 * LLAppCoreHttp::PIPELINING_DEPTH)
               : 5);
 
-    LLMeshRepoThread::sMaxConcurrentRequests = gSavedSettings.getU32("Mesh2MaxConcurrentRequests");
+    static LLCachedControl<U32> mesh2_max_req(gSavedSettings, "Mesh2MaxConcurrentRequests");
+    LLMeshRepoThread::sMaxConcurrentRequests = mesh2_max_req;
     LLMeshRepoThread::sRequestHighWater = llclamp(scale * S32(LLMeshRepoThread::sMaxConcurrentRequests),
                                                   REQUEST2_HIGH_WATER_MIN,
                                                   REQUEST2_HIGH_WATER_MAX);
diff --git a/indra/newview/lloutfitgallery.cpp b/indra/newview/lloutfitgallery.cpp
index 96be917019..b1b9f69f4f 100644
--- a/indra/newview/lloutfitgallery.cpp
+++ b/indra/newview/lloutfitgallery.cpp
@@ -416,7 +416,8 @@ void LLOutfitGallery::updateRowsIfNeeded()
 
 bool compareGalleryItem(LLOutfitGalleryItem* item1, LLOutfitGalleryItem* item2)
 {
-    if(gSavedSettings.getBOOL("OutfitGallerySortByName") ||
+    static LLCachedControl<bool> outfit_gallery_sort_by_name(gSavedSettings, "OutfitGallerySortByName");
+    if(outfit_gallery_sort_by_name ||
             ((item1->isDefaultImage() && item2->isDefaultImage()) || (!item1->isDefaultImage() && !item2->isDefaultImage())))
     {
         std::string name1 = item1->getItemName();
diff --git a/indra/newview/llphysicsmotion.cpp b/indra/newview/llphysicsmotion.cpp
index 6782aa2123..86291708b0 100644
--- a/indra/newview/llphysicsmotion.cpp
+++ b/indra/newview/llphysicsmotion.cpp
@@ -454,25 +454,26 @@ F32 LLPhysicsMotion::calculateAcceleration_local(const F32 velocity_local, const
 bool LLPhysicsMotionController::onUpdate(F32 time, U8* joint_mask)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_AVATAR;
-        // Skip if disabled globally.
-        if (!gSavedSettings.getBOOL("AvatarPhysics"))
-        {
-                return true;
-        }
+    // Skip if disabled globally.
+    static LLCachedControl<bool> av_physics(gSavedSettings, "AvatarPhysics");
+    if (!av_physics)
+    {
+            return true;
+    }
 
-        bool update_visuals = false;
-        for (motion_vec_t::iterator iter = mMotions.begin();
-             iter != mMotions.end();
-             ++iter)
-        {
-                LLPhysicsMotion *motion = (*iter);
-                update_visuals |= motion->onUpdate(time);
-        }
+    bool update_visuals = false;
+    for (motion_vec_t::iterator iter = mMotions.begin();
+            iter != mMotions.end();
+            ++iter)
+    {
+            LLPhysicsMotion *motion = (*iter);
+            update_visuals |= motion->onUpdate(time);
+    }
 
-        if (update_visuals)
-                mCharacter->updateVisualParams();
+    if (update_visuals)
+            mCharacter->updateVisualParams();
 
-        return true;
+    return true;
 }
 
 // Return true if character has to update visual params.
diff --git a/indra/newview/lltoolpie.cpp b/indra/newview/lltoolpie.cpp
index 531e657a1e..8cdc2e94f4 100644
--- a/indra/newview/lltoolpie.cpp
+++ b/indra/newview/lltoolpie.cpp
@@ -1424,7 +1424,8 @@ void LLToolPie::handleDeselect()
 
 LLTool* LLToolPie::getOverrideTool(MASK mask)
 {
-    if (gSavedSettings.getBOOL("EnableGrab"))
+    static LLCachedControl<bool> enable_grab(gSavedSettings, "EnableGrab");
+    if (enable_grab)
     {
         if (mask == DEFAULT_GRAB_MASK)
         {

From 2fa69bc13e8c629f1e3dd5eafa3dd07c83dbb4ae Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Thu, 25 Jul 2024 04:32:35 -0400
Subject: [PATCH 08/30] Fix matrix stack underflow during avatar preview
 generation (#2098)

---
 indra/newview/pipeline.cpp | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index 42a6987a18..056affb68e 100644
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -10574,10 +10574,13 @@ void LLPipeline::generateImpostor(LLVOAvatar* avatar, bool preview_avatar, bool
     sShadowRender = false;
     popRenderTypeMask();
 
-    gGL.matrixMode(LLRender::MM_PROJECTION);
-    gGL.popMatrix();
-    gGL.matrixMode(LLRender::MM_MODELVIEW);
-    gGL.popMatrix();
+    if (!preview_avatar)
+    {
+        gGL.matrixMode(LLRender::MM_PROJECTION);
+        gGL.popMatrix();
+        gGL.matrixMode(LLRender::MM_MODELVIEW);
+        gGL.popMatrix();
+    }
 
     if (!preview_avatar && !for_profile)
     {

From ca70244339291b2a06aab55e865339c534433372 Mon Sep 17 00:00:00 2001
From: Alexander Gavriliuk <alexandrgproductengine@lindenlab.com>
Date: Thu, 25 Jul 2024 13:05:47 +0200
Subject: [PATCH 09/30] #1318 Pagination in the Group Interface (small fix)

---
 indra/newview/llgroupmgr.cpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/indra/newview/llgroupmgr.cpp b/indra/newview/llgroupmgr.cpp
index 090ed7b0e2..ec2002d8c5 100644
--- a/indra/newview/llgroupmgr.cpp
+++ b/indra/newview/llgroupmgr.cpp
@@ -2332,14 +2332,16 @@ void LLGroupMgr::processCapGroupMembersResponse(const LLSD& response, U32 page_s
         group_datap->mMembers[member_id] = data;
     }
 
-    group_datap->mMemberCount = (S32)group_datap->mMembers.size();
+    U32 member_count = (U32)group_datap->mMembers.size();
+
+    group_datap->mMemberCount = (S32)member_count;
     group_datap->mMemberDataComplete = true;
     group_datap->mMemberRequestID.setNull();
     group_datap->mMemberVersion.generate();
 
     LL_INFOS("GrpMgr") << "members before: " << members_before
         << ", members loaded: " << members_loaded
-        << ", members now: " << group_datap->mMemberCount << LL_ENDL;
+        << ", members now: " << member_count << LL_ENDL;
 
     // Technically, we have this data, but to prevent completely overhauling
     // this entire system (it would be nice, but I don't have the time),
@@ -2353,9 +2355,9 @@ void LLGroupMgr::processCapGroupMembersResponse(const LLSD& response, U32 page_s
         sendGroupTitlesRequest(group_id);
     }
 
-    if (page_size && members_loaded >= page_size)
+    if (page_size && members_loaded >= page_size && member_count > members_before)
     {
-        sendCapGroupMembersRequest(group_id, page_size, (U32)group_datap->mMemberCount, sort_column);
+        sendCapGroupMembersRequest(group_id, page_size, member_count, sort_column);
     }
 
     // Make the role-member data request

From c5611e692282c98a0dd4af347a1c1e19ef823370 Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Tue, 23 Jul 2024 21:37:35 -0400
Subject: [PATCH 10/30] Fix up LLWindowShade getChild calls during draw

---
 indra/llui/llwindowshade.cpp | 46 +++++++++++++++++-------------------
 indra/llui/llwindowshade.h   |  7 ++++++
 2 files changed, 29 insertions(+), 24 deletions(-)

diff --git a/indra/llui/llwindowshade.cpp b/indra/llui/llwindowshade.cpp
index e48bc94b0a..8131a56288 100644
--- a/indra/llui/llwindowshade.cpp
+++ b/indra/llui/llwindowshade.cpp
@@ -81,8 +81,8 @@ void LLWindowShade::initFromParams(const LLWindowShade::Params& params)
     panel_p.background_visible = true;
     panel_p.bg_alpha_image = params.bg_image;
     panel_p.auto_resize = false;
-    LLLayoutPanel* notification_panel = LLUICtrlFactory::create<LLLayoutPanel>(panel_p);
-    stackp->addChild(notification_panel);
+    mNotificationsArea = LLUICtrlFactory::create<LLLayoutPanel>(panel_p);
+    stackp->addChild(mNotificationsArea);
 
     panel_p = LLUICtrlFactory::getDefaultParams<LLLayoutPanel>();
     panel_p.auto_resize = true;
@@ -92,15 +92,15 @@ void LLWindowShade::initFromParams(const LLWindowShade::Params& params)
     panel_p.mouse_opaque = false;
     panel_p.background_visible = false;
     panel_p.bg_alpha_color = params.shade_color;
-    LLLayoutPanel* dummy_panel = LLUICtrlFactory::create<LLLayoutPanel>(panel_p);
-    stackp->addChild(dummy_panel);
+    mBackgroundArea = LLUICtrlFactory::create<LLLayoutPanel>(panel_p);
+    stackp->addChild(mBackgroundArea);
 
     layout_p = LLUICtrlFactory::getDefaultParams<LLLayoutStack>();
     layout_p.rect = LLRect(0, 30, 800, 0);
     layout_p.follows.flags = FOLLOWS_ALL;
     layout_p.orientation = LLLayoutStack::HORIZONTAL;
     stackp = LLUICtrlFactory::create<LLLayoutStack>(layout_p);
-    notification_panel->addChild(stackp);
+    mNotificationsArea->addChild(stackp);
 
     panel_p = LLUICtrlFactory::getDefaultParams<LLLayoutPanel>();
     panel_p.rect.height = 30;
@@ -121,7 +121,8 @@ void LLWindowShade::initFromParams(const LLWindowShade::Params& params)
     text_p.name = "notification_text";
     text_p.use_ellipses = true;
     text_p.wrap = true;
-    panel->addChild(LLUICtrlFactory::create<LLTextBox>(text_p));
+    mNotificationsText = LLUICtrlFactory::create<LLTextBox>(text_p);
+    panel->addChild(mNotificationsText);
 
     panel_p = LLUICtrlFactory::getDefaultParams<LLLayoutPanel>();
     panel_p.auto_resize = false;
@@ -154,11 +155,9 @@ void LLWindowShade::initFromParams(const LLWindowShade::Params& params)
 
 void LLWindowShade::draw()
 {
-    LLRect message_rect = getChild<LLTextBox>("notification_text")->getTextBoundingRect();
+    LLRect message_rect = mNotificationsText->getTextBoundingRect();
 
-    LLLayoutPanel* notification_area = getChild<LLLayoutPanel>("notification_area");
-
-    notification_area->reshape(notification_area->getRect().getWidth(),
+    mNotificationsArea->reshape(mNotificationsArea->getRect().getWidth(),
         llclamp(message_rect.getHeight() + 15,
                 llmax(mFormHeight, MIN_NOTIFICATION_AREA_HEIGHT),
                 MAX_NOTIFICATION_AREA_HEIGHT));
@@ -176,21 +175,21 @@ void LLWindowShade::draw()
     {
         hide();
     }
-    else if (notification_area->getVisibleAmount() < 0.01f)
+    else if (mNotificationsArea->getVisibleAmount() < 0.01f)
     {
         displayLatestNotification();
     }
 
-    if (!notification_area->getVisible() && (notification_area->getVisibleAmount() < 0.001f))
+    if (!mNotificationsArea->getVisible() && (mNotificationsArea->getVisibleAmount() < 0.001f))
     {
-        getChildRef<LLLayoutPanel>("background_area").setBackgroundVisible(false);
+        mBackgroundArea->setBackgroundVisible(false);
         setMouseOpaque(false);
     }
 }
 
 void LLWindowShade::hide()
 {
-    getChildRef<LLLayoutPanel>("notification_area").setVisible(false);
+    mNotificationsArea->setVisible(false);
 }
 
 void LLWindowShade::onCloseNotification()
@@ -244,13 +243,12 @@ void LLWindowShade::displayLatestNotification()
     LLSD payload = notification->getPayload();
 
     LLNotificationFormPtr formp = notification->getForm();
-    LLLayoutPanel& notification_area = getChildRef<LLLayoutPanel>("notification_area");
-    notification_area.getChild<LLUICtrl>("notification_icon")->setValue(notification->getIcon());
-    notification_area.getChild<LLUICtrl>("notification_text")->setValue(notification->getMessage());
-    notification_area.getChild<LLUICtrl>("notification_text")->setToolTip(notification->getMessage());
+    mNotificationsArea->getChild<LLUICtrl>("notification_icon")->setValue(notification->getIcon());
+    mNotificationsText->setValue(notification->getMessage());
+    mNotificationsText->setToolTip(notification->getMessage());
 
     LLNotificationForm::EIgnoreType ignore_type = formp->getIgnoreType();
-    LLLayoutPanel& form_elements = notification_area.getChildRef<LLLayoutPanel>("form_elements");
+    LLLayoutPanel& form_elements = mNotificationsArea->getChildRef<LLLayoutPanel>("form_elements");
     form_elements.deleteAllChildren();
     form_elements.reshape(form_elements.getRect().getWidth(), MIN_NOTIFICATION_AREA_HEIGHT);
 
@@ -355,25 +353,25 @@ void LLWindowShade::displayLatestNotification()
         (*it)->translate(0, delta_y);
     }
 
-    getChildRef<LLLayoutPanel>("notification_area").setVisible(true);
-    getChildRef<LLLayoutPanel>("background_area").setBackgroundVisible(mModal);
+    mNotificationsArea->setVisible(true);
+    mBackgroundArea->setBackgroundVisible(mModal);
 
     setMouseOpaque(mModal);
 }
 
 void LLWindowShade::setBackgroundImage(LLUIImage* image)
 {
-    getChild<LLLayoutPanel>("notification_area")->setTransparentImage(image);
+    mNotificationsArea->setTransparentImage(image);
 }
 
 void LLWindowShade::setTextColor(LLColor4 color)
 {
-    getChild<LLTextBox>("notification_text")->setColor(color);
+    mNotificationsText->setColor(color);
 }
 
 bool LLWindowShade::isShown() const
 {
-    return getChildRef<LLLayoutPanel>("notification_area").getVisible();
+    return mNotificationsArea->getVisible();
 }
 
 void LLWindowShade::setCanClose(bool can_close)
diff --git a/indra/llui/llwindowshade.h b/indra/llui/llwindowshade.h
index a401394d78..da29188943 100644
--- a/indra/llui/llwindowshade.h
+++ b/indra/llui/llwindowshade.h
@@ -31,6 +31,9 @@
 #include "llnotifications.h"
 #include "lluiimage.h"
 
+class LLLayoutPanel;
+class LLTextBox;
+
 class LLWindowShade : public LLUICtrl
 {
 public:
@@ -68,6 +71,10 @@ private:
     void onEnterNotificationText(LLUICtrl* ctrl, const std::string& name);
     void onClickIgnore(LLUICtrl* ctrl);
 
+    LLLayoutPanel* mBackgroundArea = nullptr;
+    LLLayoutPanel* mNotificationsArea = nullptr;
+    LLTextBox* mNotificationsText = nullptr;
+
     std::vector<LLNotificationPtr>  mNotifications;
     LLSD                mNotificationResponse;
     bool                mModal;

From 39a8bba844a6fadf0f528a141c0136a1ae45af42 Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Tue, 23 Jul 2024 21:38:06 -0400
Subject: [PATCH 11/30] Fix up LLScrollListCtrl getChild during draw

---
 indra/llui/llscrolllistctrl.cpp | 29 ++++++++++++-----------------
 indra/llui/llscrolllistctrl.h   |  2 +-
 2 files changed, 13 insertions(+), 18 deletions(-)

diff --git a/indra/llui/llscrolllistctrl.cpp b/indra/llui/llscrolllistctrl.cpp
index 8512555b49..10d0ae0678 100644
--- a/indra/llui/llscrolllistctrl.cpp
+++ b/indra/llui/llscrolllistctrl.cpp
@@ -196,7 +196,6 @@ LLScrollListCtrl::LLScrollListCtrl(const LLScrollListCtrl::Params& p)
     mHighlightedItem(-1),
     mBorder(NULL),
     mSortCallback(NULL),
-    mCommentTextView(NULL),
     mNumDynamicWidthColumns(0),
     mTotalStaticColumnWidth(0),
     mTotalColumnPadding(0),
@@ -288,13 +287,6 @@ LLScrollListCtrl::LLScrollListCtrl(const LLScrollListCtrl::Params& p)
         addColumn(*row_it);
     }
 
-    for (LLInitParam::ParamIterator<LLScrollListItem::Params>::const_iterator row_it = p.contents.rows.begin();
-        row_it != p.contents.rows.end();
-        ++row_it)
-    {
-        addRow(*row_it);
-    }
-
     LLTextBox::Params text_p;
     text_p.name("comment_text");
     text_p.border_visible(false);
@@ -302,7 +294,15 @@ LLScrollListCtrl::LLScrollListCtrl(const LLScrollListCtrl::Params& p)
     text_p.follows.flags(FOLLOWS_ALL);
     // word wrap was added accroding to the EXT-6841
     text_p.wrap(true);
-    addChild(LLUICtrlFactory::create<LLTextBox>(text_p));
+    mCommentText = LLUICtrlFactory::create<LLTextBox>(text_p);
+    addChild(mCommentText);
+
+    for (LLInitParam::ParamIterator<LLScrollListItem::Params>::const_iterator row_it = p.contents.rows.begin();
+        row_it != p.contents.rows.end();
+        ++row_it)
+    {
+        addRow(*row_it);
+    }
 }
 
 S32 LLScrollListCtrl::getSearchColumn()
@@ -541,12 +541,7 @@ void LLScrollListCtrl::updateLayout()
         getRect().getWidth() - 2 * mBorderThickness,
         getRect().getHeight() - (2 * mBorderThickness ) - heading_size );
 
-    if (mCommentTextView == NULL)
-    {
-        mCommentTextView = getChildView("comment_text");
-    }
-
-    mCommentTextView->setShape(mItemListRect);
+    mCommentText->setShape(mItemListRect);
 
     // how many lines of content in a single "page"
     S32 page_lines =  getLinesPerPage();
@@ -1244,7 +1239,7 @@ void LLScrollListCtrl::deselectAllItems(bool no_commit_on_change)
 
 void LLScrollListCtrl::setCommentText(const std::string& comment_text)
 {
-    getChild<LLTextBox>("comment_text")->setValue(comment_text);
+    mCommentText->setValue(comment_text);
 }
 
 LLScrollListItem* LLScrollListCtrl::addSeparator(EAddPosition pos)
@@ -1727,7 +1722,7 @@ void LLScrollListCtrl::draw()
 
     updateColumns();
 
-    getChildView("comment_text")->setVisible(mItemList.empty());
+    mCommentText->setVisible(mItemList.empty());
 
     drawItems();
 
diff --git a/indra/llui/llscrolllistctrl.h b/indra/llui/llscrolllistctrl.h
index f25ba61fd4..1f9f26e08b 100644
--- a/indra/llui/llscrolllistctrl.h
+++ b/indra/llui/llscrolllistctrl.h
@@ -530,7 +530,7 @@ private:
     class LLViewBorder* mBorder;
     LLHandle<LLContextMenu> mPopupMenuHandle;
 
-    LLView          *mCommentTextView;
+    LLTextBox*      mCommentText = nullptr;
 
     LLWString       mSearchString;
     LLFrameTimer    mSearchTimer;

From 5a3a6c6914b9c7a3b8e9f51075035326329d947d Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Tue, 23 Jul 2024 21:38:43 -0400
Subject: [PATCH 12/30] Fix excessive getChild calls from LLScrollBar reshape

---
 indra/llui/llscrollbar.cpp | 24 ++++++++++++------------
 indra/llui/llscrollbar.h   |  3 +++
 2 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/indra/llui/llscrollbar.cpp b/indra/llui/llscrollbar.cpp
index 9c73b1ba3f..d0eec387bd 100644
--- a/indra/llui/llscrollbar.cpp
+++ b/indra/llui/llscrollbar.cpp
@@ -113,7 +113,8 @@ LLScrollbar::LLScrollbar(const Params & p)
     up_btn.tab_stop(false);
     up_btn.follows.flags = (mOrientation == VERTICAL ? (FOLLOWS_RIGHT | FOLLOWS_TOP) : (FOLLOWS_LEFT | FOLLOWS_BOTTOM));
 
-    addChild(LLUICtrlFactory::create<LLButton>(up_btn));
+    mLineUpBtn = LLUICtrlFactory::create<LLButton>(up_btn);
+    addChild(mLineUpBtn);
 
     LLButton::Params down_btn(mOrientation == VERTICAL ? p.down_button : p.right_button);
     down_btn.name(std::string("Line Down"));
@@ -123,7 +124,8 @@ LLScrollbar::LLScrollbar(const Params & p)
     down_btn.mouse_held_callback.function(boost::bind(&LLScrollbar::onLineDownBtnPressed, this, _2));
     down_btn.tab_stop(false);
 
-    addChild(LLUICtrlFactory::create<LLButton>(down_btn));
+    mLineDownBtn = LLUICtrlFactory::create<LLButton>(down_btn);
+    addChild(mLineDownBtn);
 }
 
 
@@ -468,22 +470,20 @@ void LLScrollbar::reshape(S32 width, S32 height, bool called_from_parent)
 {
     if (width == getRect().getWidth() && height == getRect().getHeight()) return;
     LLView::reshape( width, height, called_from_parent );
-    LLButton* up_button = getChild<LLButton>("Line Up");
-    LLButton* down_button = getChild<LLButton>("Line Down");
 
     if (mOrientation == VERTICAL)
     {
-        up_button->reshape(up_button->getRect().getWidth(), llmin(getRect().getHeight() / 2, mThickness));
-        down_button->reshape(down_button->getRect().getWidth(), llmin(getRect().getHeight() / 2, mThickness));
-        up_button->setOrigin(0, getRect().getHeight() - up_button->getRect().getHeight());
-        down_button->setOrigin(0, 0);
+        mLineUpBtn->reshape(mLineUpBtn->getRect().getWidth(), llmin(getRect().getHeight() / 2, mThickness));
+        mLineDownBtn->reshape(mLineDownBtn->getRect().getWidth(), llmin(getRect().getHeight() / 2, mThickness));
+        mLineUpBtn->setOrigin(0, getRect().getHeight() - mLineUpBtn->getRect().getHeight());
+        mLineDownBtn->setOrigin(0, 0);
     }
     else
     {
-        up_button->reshape(llmin(getRect().getWidth() / 2, mThickness), up_button->getRect().getHeight());
-        down_button->reshape(llmin(getRect().getWidth() / 2, mThickness), down_button->getRect().getHeight());
-        up_button->setOrigin(0, 0);
-        down_button->setOrigin(getRect().getWidth() - down_button->getRect().getWidth(), 0);
+        mLineUpBtn->reshape(llmin(getRect().getWidth() / 2, mThickness), mLineUpBtn->getRect().getHeight());
+        mLineDownBtn->reshape(llmin(getRect().getWidth() / 2, mThickness), mLineDownBtn->getRect().getHeight());
+        mLineUpBtn->setOrigin(0, 0);
+        mLineDownBtn->setOrigin(getRect().getWidth() - mLineDownBtn->getRect().getWidth(), 0);
     }
     updateThumbRect();
 }
diff --git a/indra/llui/llscrollbar.h b/indra/llui/llscrollbar.h
index 7b935aa51b..9607355a9d 100644
--- a/indra/llui/llscrollbar.h
+++ b/indra/llui/llscrollbar.h
@@ -161,6 +161,9 @@ private:
     LLUIImagePtr        mTrackImageH;
 
     S32                 mThickness;
+
+    LLButton*           mLineUpBtn = nullptr;
+    LLButton*           mLineDownBtn = nullptr;
 };
 
 

From 316d815e7b97091a6ae34d48fc7672c59d613713 Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Tue, 23 Jul 2024 21:39:30 -0400
Subject: [PATCH 13/30] Fix getChild calls during draw in LLProgressView

---
 indra/newview/llprogressview.cpp | 15 +++++++++------
 indra/newview/llprogressview.h   |  4 ++++
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/indra/newview/llprogressview.cpp b/indra/newview/llprogressview.cpp
index 7bef0339c5..135e42437a 100644
--- a/indra/newview/llprogressview.cpp
+++ b/indra/newview/llprogressview.cpp
@@ -81,6 +81,11 @@ bool LLProgressView::postBuild()
 {
     mProgressBar = getChild<LLProgressBar>("login_progress_bar");
 
+    mLogosLabel = getChild<LLTextBox>("logos_lbl");
+
+    mProgressText = getChild<LLTextBox>("progress_text");
+    mMessageText = getChild<LLTextBox>("message_text");
+
     // media control that is used to play intro video
     mMediaCtrl = getChild<LLMediaCtrl>("login_media_panel");
     mMediaCtrl->setVisible( false );        // hidden initially
@@ -238,9 +243,8 @@ void LLProgressView::drawLogos(F32 alpha)
 
     // logos are tied to label,
     // due to potential resizes we have to figure offsets out on draw or resize
-    LLTextBox *logos_label = getChild<LLTextBox>("logos_lbl");
     S32 offset_x, offset_y;
-    logos_label->localPointToScreen(0, 0, &offset_x, &offset_y);
+    mLogosLabel->localPointToScreen(0, 0, &offset_x, &offset_y);
     std::vector<TextureData>::const_iterator iter = mLogosList.begin();
     std::vector<TextureData>::const_iterator end = mLogosList.end();
     for (; iter != end; iter++)
@@ -325,7 +329,7 @@ void LLProgressView::draw()
 
 void LLProgressView::setText(const std::string& text)
 {
-    getChild<LLUICtrl>("progress_text")->setValue(text);
+    mProgressText->setValue(text);
 }
 
 void LLProgressView::setPercent(const F32 percent)
@@ -336,7 +340,7 @@ void LLProgressView::setPercent(const F32 percent)
 void LLProgressView::setMessage(const std::string& msg)
 {
     mMessage = msg;
-    getChild<LLUICtrl>("message_text")->setValue(mMessage);
+    mMessageText->setValue(mMessage);
 }
 
 void LLProgressView::loadLogo(const std::string &path,
@@ -387,8 +391,7 @@ void LLProgressView::initLogos()
     S32 icon_width, icon_height;
 
     // We don't know final screen rect yet, so we can't precalculate position fully
-    LLTextBox *logos_label = getChild<LLTextBox>("logos_lbl");
-    S32 texture_start_x = (S32)logos_label->getFont()->getWidthF32(logos_label->getText()) + default_pad;
+    S32 texture_start_x = (S32)mLogosLabel->getFont()->getWidthF32(mLogosLabel->getText()) + default_pad;
     S32 texture_start_y = -7;
 
     // Normally we would just preload these textures from textures.xml,
diff --git a/indra/newview/llprogressview.h b/indra/newview/llprogressview.h
index db3f4a2e32..15b04a8eb9 100644
--- a/indra/newview/llprogressview.h
+++ b/indra/newview/llprogressview.h
@@ -36,6 +36,7 @@ class LLImageRaw;
 class LLButton;
 class LLProgressBar;
 class LLViewerTexture;
+class LLTextBox;
 
 class LLProgressView :
     public LLPanel,
@@ -85,6 +86,9 @@ public:
 protected:
     LLProgressBar* mProgressBar;
     LLMediaCtrl* mMediaCtrl;
+    LLTextBox* mLogosLabel = nullptr;
+    LLTextBox* mProgressText = nullptr;
+    LLTextBox* mMessageText = nullptr;
     F32 mPercentDone;
     std::string mMessage;
     LLButton*   mCancelBtn;

From 29c8fb0a76b4271471c5cbdf356d5256cb37e3ea Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Tue, 23 Jul 2024 21:41:27 -0400
Subject: [PATCH 14/30] Fix excessive getChild calls during teleport from
 LLPanelGroup

---
 indra/newview/llpanelgroup.cpp | 127 +++++++++++++++------------------
 indra/newview/llpanelgroup.h   |  14 +++-
 2 files changed, 68 insertions(+), 73 deletions(-)

diff --git a/indra/newview/llpanelgroup.cpp b/indra/newview/llpanelgroup.cpp
index 519f157973..598df0135e 100644
--- a/indra/newview/llpanelgroup.cpp
+++ b/indra/newview/llpanelgroup.cpp
@@ -113,7 +113,7 @@ void LLPanelGroup::onOpen(const LLSD& key)
     if(!key.has("action"))
     {
         setGroupID(group_id);
-        getChild<LLAccordionCtrl>("groups_accordion")->expandDefaultTab();
+        mGroupsAccordion->expandDefaultTab();
         return;
     }
 
@@ -148,24 +148,26 @@ void LLPanelGroup::onOpen(const LLSD& key)
 
 bool LLPanelGroup::postBuild()
 {
+    mGroupsAccordion = getChild<LLAccordionCtrl>("groups_accordion");
+
     mDefaultNeedsApplyMesg = getString("default_needs_apply_text");
     mWantApplyMesg = getString("want_apply_text");
 
-    LLButton* button;
+    mButtonApply = getChild<LLButton>("btn_apply");
+    mButtonApply->setClickedCallback(onBtnApply, this);
+    mButtonApply->setVisible(true);
+    mButtonApply->setEnabled(false);
 
-    button = getChild<LLButton>("btn_apply");
-    button->setClickedCallback(onBtnApply, this);
-    button->setVisible(true);
-    button->setEnabled(false);
+    mButtonCall = getChild<LLButton>("btn_call");
+    mButtonCall->setClickedCallback(onBtnGroupCallClicked, this);
 
-    button = getChild<LLButton>("btn_call");
-    button->setClickedCallback(onBtnGroupCallClicked, this);
+    mButtonChat = getChild<LLButton>("btn_chat");
+    mButtonChat->setClickedCallback(onBtnGroupChatClicked, this);
 
-    button = getChild<LLButton>("btn_chat");
-    button->setClickedCallback(onBtnGroupChatClicked, this);
+    mButtonRefresh = getChild<LLButton>("btn_refresh");
+    mButtonRefresh->setClickedCallback(onBtnRefresh, this);
 
-    button = getChild<LLButton>("btn_refresh");
-    button->setClickedCallback(onBtnRefresh, this);
+    mButtonCancel = getChild<LLButton>("btn_cancel");
 
     childSetCommitCallback("back",boost::bind(&LLPanelGroup::onBackBtnClick,this),NULL);
 
@@ -184,7 +186,7 @@ bool LLPanelGroup::postBuild()
     if(panel_general)
     {
         panel_general->setupCtrls(this);
-        button = panel_general->getChild<LLButton>("btn_join");
+        LLButton* button = panel_general->getChild<LLButton>("btn_join");
         button->setVisible(false);
         button->setEnabled(true);
 
@@ -199,9 +201,8 @@ bool LLPanelGroup::postBuild()
     return true;
 }
 
-void LLPanelGroup::reposButton(const std::string& name)
+void LLPanelGroup::reposButton(LLButton* button)
 {
-    LLButton* button = findChild<LLButton>(name);
     if(!button)
         return;
     LLRect btn_rect = button->getRect();
@@ -211,23 +212,20 @@ void LLPanelGroup::reposButton(const std::string& name)
 
 void LLPanelGroup::reposButtons()
 {
-    LLButton* button_refresh = findChild<LLButton>("btn_refresh");
-    LLButton* button_cancel = findChild<LLButton>("btn_cancel");
-
-    if(button_refresh && button_cancel && button_refresh->getVisible() && button_cancel->getVisible())
+    if(mButtonRefresh && mButtonCancel && mButtonRefresh->getVisible() && mButtonCancel->getVisible())
     {
-        LLRect btn_refresh_rect = button_refresh->getRect();
-        LLRect btn_cancel_rect = button_cancel->getRect();
+        LLRect btn_refresh_rect = mButtonRefresh->getRect();
+        LLRect btn_cancel_rect = mButtonCancel->getRect();
         btn_refresh_rect.setLeftTopAndSize( btn_cancel_rect.mLeft + btn_cancel_rect.getWidth() + 2,
             btn_refresh_rect.getHeight() + 2, btn_refresh_rect.getWidth(), btn_refresh_rect.getHeight());
-        button_refresh->setRect(btn_refresh_rect);
+        mButtonRefresh->setRect(btn_refresh_rect);
     }
 
-    reposButton("btn_apply");
-    reposButton("btn_refresh");
-    reposButton("btn_cancel");
-    reposButton("btn_chat");
-    reposButton("btn_call");
+    reposButton(mButtonApply);
+    reposButton(mButtonRefresh);
+    reposButton(mButtonCancel);
+    reposButton(mButtonChat);
+    reposButton(mButtonCall);
 }
 
 void LLPanelGroup::reshape(S32 width, S32 height, bool called_from_parent )
@@ -279,9 +277,9 @@ void LLPanelGroup::onBtnJoin()
     }
     else
     {
-    LL_DEBUGS() << "joining group: " << mID << LL_ENDL;
-    LLGroupActions::join(mID);
-}
+        LL_DEBUGS() << "joining group: " << mID << LL_ENDL;
+        LLGroupActions::join(mID);
+    }
 }
 
 void LLPanelGroup::changed(LLGroupChange gc)
@@ -299,7 +297,7 @@ void LLPanelGroup::onChange(EStatusType status, const LLSD& channelInfo, bool pr
         return;
     }
 
-    childSetEnabled("btn_call", LLVoiceClient::getInstance()->voiceEnabled() && LLVoiceClient::getInstance()->isVoiceWorking());
+    mButtonCall->setEnabled(LLVoiceClient::getInstance()->voiceEnabled() && LLVoiceClient::getInstance()->isVoiceWorking());
 }
 
 void LLPanelGroup::notifyObservers()
@@ -372,32 +370,23 @@ void LLPanelGroup::setGroupID(const LLUUID& group_id)
         group_name_ctrl->setToolTip(group_name);
     }
 
-    LLButton* button_apply = findChild<LLButton>("btn_apply");
-    LLButton* button_refresh = findChild<LLButton>("btn_refresh");
-
-    LLButton* button_cancel = findChild<LLButton>("btn_cancel");
-    LLButton* button_call = findChild<LLButton>("btn_call");
-    LLButton* button_chat = findChild<LLButton>("btn_chat");
-
-
     bool is_null_group_id = group_id == LLUUID::null;
-    if(button_apply)
-        button_apply->setVisible(!is_null_group_id);
-    if(button_refresh)
-        button_refresh->setVisible(!is_null_group_id);
+    if(mButtonApply)
+        mButtonApply->setVisible(!is_null_group_id);
+    if(mButtonRefresh)
+        mButtonRefresh->setVisible(!is_null_group_id);
 
-    if(button_cancel)
-        button_cancel->setVisible(!is_null_group_id);
+    if(mButtonCancel)
+        mButtonCancel->setVisible(!is_null_group_id);
 
-    if(button_call)
-            button_call->setVisible(!is_null_group_id);
-    if(button_chat)
-            button_chat->setVisible(!is_null_group_id);
+    if(mButtonCall)
+            mButtonCall->setVisible(!is_null_group_id);
+    if(mButtonChat)
+            mButtonChat->setVisible(!is_null_group_id);
 
     getChild<LLUICtrl>("prepend_founded_by")->setVisible(!is_null_group_id);
 
-    LLAccordionCtrl* tab_ctrl = getChild<LLAccordionCtrl>("groups_accordion");
-    tab_ctrl->reset();
+    mGroupsAccordion->reset();
 
     LLAccordionCtrlTab* tab_general = getChild<LLAccordionCtrlTab>("group_general_tab");
     LLAccordionCtrlTab* tab_roles = getChild<LLAccordionCtrlTab>("group_roles_tab");
@@ -431,10 +420,10 @@ void LLPanelGroup::setGroupID(const LLUUID& group_id)
         getChild<LLUICtrl>("group_name")->setVisible(false);
         getChild<LLUICtrl>("group_name_editor")->setVisible(true);
 
-        if(button_call)
-            button_call->setVisible(false);
-        if(button_chat)
-            button_chat->setVisible(false);
+        if(mButtonCall)
+            mButtonCall->setVisible(false);
+        if(mButtonChat)
+            mButtonChat->setVisible(false);
     }
     else
     {
@@ -463,15 +452,15 @@ void LLPanelGroup::setGroupID(const LLUUID& group_id)
         getChild<LLUICtrl>("group_name")->setVisible(true);
         getChild<LLUICtrl>("group_name_editor")->setVisible(false);
 
-        if(button_apply)
-            button_apply->setVisible(is_member);
-        if(button_call)
-            button_call->setVisible(is_member);
-        if(button_chat)
-            button_chat->setVisible(is_member);
+        if(mButtonApply)
+            mButtonApply->setVisible(is_member);
+        if(mButtonCall)
+            mButtonCall->setVisible(is_member);
+        if(mButtonChat)
+            mButtonChat->setVisible(is_member);
     }
 
-    tab_ctrl->arrange();
+    mGroupsAccordion->arrange();
 
     reposButtons();
     update(GC_ALL);//show/hide "join" button if data is already ready
@@ -539,20 +528,18 @@ void LLPanelGroup::draw()
     if (mRefreshTimer.hasExpired())
     {
         mRefreshTimer.stop();
-        childEnable("btn_refresh");
-        childEnable("groups_accordion");
+        if(mButtonRefresh) mButtonRefresh->setEnabled(true);
+        mGroupsAccordion->setEnabled(true);
     }
 
-    LLButton* button_apply = findChild<LLButton>("btn_apply");
-
-    if(button_apply && button_apply->getVisible())
+    if(mButtonApply && mButtonApply->getVisible())
     {
         bool enable = false;
         std::string mesg;
         for(std::vector<LLPanelGroupTab* >::iterator it = mTabs.begin();it!=mTabs.end();++it)
             enable = enable || (*it)->needsApply(mesg);
 
-        childSetEnabled("btn_apply", enable);
+        mButtonApply->setEnabled(enable);
     }
 }
 
@@ -568,8 +555,8 @@ void LLPanelGroup::refreshData()
     setGroupID(getID());
 
     // 5 second timeout
-    childDisable("btn_refresh");
-    childDisable("groups_accordion");
+    if(mButtonRefresh) mButtonRefresh->setEnabled(false);
+    mGroupsAccordion->setEnabled(false);
 
     mRefreshTimer.start();
     mRefreshTimer.setTimerExpirySec(5);
diff --git a/indra/newview/llpanelgroup.h b/indra/newview/llpanelgroup.h
index ede8118720..1dbc8c32ff 100644
--- a/indra/newview/llpanelgroup.h
+++ b/indra/newview/llpanelgroup.h
@@ -33,11 +33,12 @@
 
 class LLOfferInfo;
 
-const F32 UPDATE_MEMBERS_SECONDS_PER_FRAME = 0.005; // 5ms
+const F32 UPDATE_MEMBERS_SECONDS_PER_FRAME = 0.005f; // 5ms
 
 // Forward declares
 class LLPanelGroupTab;
 class LLTabContainer;
+class LLAccordionCtrl;
 class LLAgent;
 
 
@@ -98,7 +99,7 @@ protected:
     static void onBtnGroupCallClicked(void*);
     static void onBtnGroupChatClicked(void*);
 
-    void reposButton(const std::string& name);
+    void reposButton(LLButton* button);
     void reposButtons();
 
 
@@ -114,7 +115,14 @@ protected:
 
     std::vector<LLPanelGroupTab* > mTabs;
 
-    LLButton*       mButtonJoin;
+    LLAccordionCtrl* mGroupsAccordion = nullptr;
+
+    LLButton*       mButtonJoin = nullptr;
+    LLButton*       mButtonApply = nullptr;
+    LLButton*       mButtonCall = nullptr;
+    LLButton*       mButtonChat = nullptr;
+    LLButton*       mButtonRefresh = nullptr;
+    LLButton*       mButtonCancel = nullptr;
     LLUICtrl*       mJoinText;
 };
 

From 7dd3f5db0b7da458a49df8ae2f40138a83021dec Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Tue, 23 Jul 2024 21:41:58 -0400
Subject: [PATCH 15/30] Fix getChild calls during draw in LLFloaterWorldMap

---
 indra/newview/llfloaterworldmap.cpp | 122 +++++++++++++++++-----------
 indra/newview/llfloaterworldmap.h   |  30 ++++++-
 2 files changed, 102 insertions(+), 50 deletions(-)

diff --git a/indra/newview/llfloaterworldmap.cpp b/indra/newview/llfloaterworldmap.cpp
index 2a72a361d6..d459716fc4 100755
--- a/indra/newview/llfloaterworldmap.cpp
+++ b/indra/newview/llfloaterworldmap.cpp
@@ -39,6 +39,8 @@
 #include "llbutton.h"
 #include "llcallingcard.h"
 #include "llcombobox.h"
+#include "llcheckboxctrl.h"
+#include "llsliderctrl.h"
 #include "llviewercontrol.h"
 #include "llcommandhandler.h"
 #include "lldraghandle.h"
@@ -317,15 +319,36 @@ bool LLFloaterWorldMap::postBuild()
     mMapView = dynamic_cast<LLWorldMapView*>(getChild<LLPanel>("objects_mapview"));
     mMapView->setPan(0, 0, true);
 
+    mTeleportButton = getChild<LLButton>("Teleport");
+    mShowDestinationButton = getChild<LLButton>("Show Destination");
+    mCopySlurlButton = getChild<LLButton>("copy_slurl");
+    mGoHomeButton = getChild<LLButton>("Go Home");
+
+    mPeopleCheck = getChild<LLCheckBoxCtrl>("people_chk");
+    mInfohubCheck = getChild<LLCheckBoxCtrl>("infohub_chk");
+    mTelehubCheck = getChild<LLCheckBoxCtrl>("telehub_chk");
+    mLandSaleCheck = getChild<LLCheckBoxCtrl>("land_for_sale_chk");
+    mEventsCheck = getChild<LLCheckBoxCtrl>("event_chk");
+    mEventsMatureCheck = getChild<LLCheckBoxCtrl>("events_mature_chk");
+    mEventsAdultCheck = getChild<LLCheckBoxCtrl>("events_adult_chk");
+
+    mAvatarIcon = getChild<LLUICtrl>("avatar_icon");
+    mLandmarkIcon = getChild<LLUICtrl>("landmark_icon");
+    mLocationIcon = getChild<LLUICtrl>("location_icon");
+
+    mTeleportCoordSpinX = getChild<LLUICtrl>("teleport_coordinate_x");
+    mTeleportCoordSpinY = getChild<LLUICtrl>("teleport_coordinate_y");
+    mTeleportCoordSpinZ = getChild<LLUICtrl>("teleport_coordinate_z");
+
     LLComboBox *avatar_combo = getChild<LLComboBox>("friend combo");
     avatar_combo->selectFirstItem();
     avatar_combo->setPrearrangeCallback( boost::bind(&LLFloaterWorldMap::onAvatarComboPrearrange, this) );
     avatar_combo->setTextChangedCallback( boost::bind(&LLFloaterWorldMap::onComboTextEntry, this) );
     mListFriendCombo = dynamic_cast<LLCtrlListInterface *>(avatar_combo);
 
-    LLSearchEditor *location_editor = getChild<LLSearchEditor>("location");
-    location_editor->setFocusChangedCallback(boost::bind(&LLFloaterWorldMap::onLocationFocusChanged, this, _1));
-    location_editor->setTextChangedCallback( boost::bind(&LLFloaterWorldMap::onSearchTextEntry, this));
+    mLocationEditor = getChild<LLSearchEditor>("location");
+    mLocationEditor->setFocusChangedCallback(boost::bind(&LLFloaterWorldMap::onLocationFocusChanged, this, _1));
+    mLocationEditor->setTextChangedCallback( boost::bind(&LLFloaterWorldMap::onSearchTextEntry, this));
 
     getChild<LLScrollListCtrl>("search_results")->setDoubleClickCallback( boost::bind(&LLFloaterWorldMap::onClickTeleportBtn, this));
     mListSearchResults = childGetListInterface("search_results");
@@ -336,8 +359,9 @@ bool LLFloaterWorldMap::postBuild()
     landmark_combo->setTextChangedCallback( boost::bind(&LLFloaterWorldMap::onComboTextEntry, this) );
     mListLandmarkCombo = dynamic_cast<LLCtrlListInterface *>(landmark_combo);
 
+    mZoomSlider = getChild<LLSliderCtrl>("zoom slider");
     F32 slider_zoom = mMapView->getZoom();
-    getChild<LLUICtrl>("zoom slider")->setValue(slider_zoom);
+    mZoomSlider->setValue(slider_zoom);
 
     getChild<LLPanel>("expand_btn_panel")->setMouseDownCallback(boost::bind(&LLFloaterWorldMap::onExpandCollapseBtn, this));
 
@@ -414,7 +438,7 @@ void LLFloaterWorldMap::onOpen(const LLSD& key)
         const LLUUID landmark_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LANDMARK);
         LLInventoryModelBackgroundFetch::instance().start(landmark_folder_id);
 
-        getChild<LLUICtrl>("location")->setFocus( true);
+        mLocationEditor->setFocus( true);
         gFocusMgr.triggerFocusFlash();
 
         buildAvatarIDList();
@@ -452,9 +476,9 @@ bool LLFloaterWorldMap::handleScrollWheel(S32 x, S32 y, S32 clicks)
         S32 map_y = y - mMapView->getRect().mBottom;
         if (mMapView->pointInView(map_x, map_y))
         {
-            F32 old_slider_zoom = (F32) getChild<LLUICtrl>("zoom slider")->getValue().asReal();
+            F32 old_slider_zoom = (F32) mZoomSlider->getValue().asReal();
             F32 slider_zoom     = old_slider_zoom + ((F32) clicks * -0.3333f);
-            getChild<LLUICtrl>("zoom slider")->setValue(LLSD(slider_zoom));
+            mZoomSlider->setValue(LLSD(slider_zoom));
             mMapView->zoomWithPivot(slider_zoom, map_x, map_y);
             return true;
         }
@@ -483,32 +507,32 @@ void LLFloaterWorldMap::draw()
     LLViewerRegion* regionp = gAgent.getRegion();
     bool agent_on_prelude = (regionp && regionp->isPrelude());
     bool enable_go_home = gAgent.isGodlike() || !agent_on_prelude;
-    getChildView("Go Home")->setEnabled(enable_go_home);
+    mGoHomeButton->setEnabled(enable_go_home);
 
     updateLocation();
 
     LLTracker::ETrackingStatus tracking_status = LLTracker::getTrackingStatus();
     if (LLTracker::TRACKING_AVATAR == tracking_status)
     {
-        getChild<LLUICtrl>("avatar_icon")->setColor( map_track_color);
+        mAvatarIcon->setColor( map_track_color);
     }
     else
     {
-        getChild<LLUICtrl>("avatar_icon")->setColor( map_track_disabled_color);
+        mAvatarIcon->setColor( map_track_disabled_color);
     }
 
     if (LLTracker::TRACKING_LANDMARK == tracking_status)
     {
-        getChild<LLUICtrl>("landmark_icon")->setColor( map_track_color);
+        mLandmarkIcon->setColor( map_track_color);
     }
     else
     {
-        getChild<LLUICtrl>("landmark_icon")->setColor( map_track_disabled_color);
+        mLandmarkIcon->setColor( map_track_disabled_color);
     }
 
     if (LLTracker::TRACKING_LOCATION == tracking_status)
     {
-        getChild<LLUICtrl>("location_icon")->setColor( map_track_color);
+        mLocationIcon->setColor( map_track_color);
     }
     else
     {
@@ -518,11 +542,11 @@ void LLFloaterWorldMap::draw()
             double value = fmod(seconds, 2);
             value = 0.5 + 0.5*cos(value * F_PI);
             LLColor4 loading_color(0.0, F32(value/2), F32(value), 1.0);
-            getChild<LLUICtrl>("location_icon")->setColor( loading_color);
+            mLocationIcon->setColor( loading_color);
         }
         else
         {
-            getChild<LLUICtrl>("location_icon")->setColor( map_track_disabled_color);
+            mLocationIcon->setColor( map_track_disabled_color);
         }
     }
 
@@ -532,27 +556,27 @@ void LLFloaterWorldMap::draw()
         centerOnTarget(true);
     }
 
-    getChildView("Teleport")->setEnabled((bool)tracking_status);
+    mTeleportButton->setEnabled((bool)tracking_status);
     //  getChildView("Clear")->setEnabled((bool)tracking_status);
-    getChildView("Show Destination")->setEnabled((bool)tracking_status || LLWorldMap::getInstance()->isTracking());
-    getChildView("copy_slurl")->setEnabled((mSLURL.isValid()) );
+    mShowDestinationButton->setEnabled((bool)tracking_status || LLWorldMap::getInstance()->isTracking());
+    mCopySlurlButton->setEnabled((mSLURL.isValid()) );
 
     setMouseOpaque(true);
     getDragHandle()->setMouseOpaque(true);
 
-    mMapView->zoom((F32)getChild<LLUICtrl>("zoom slider")->getValue().asReal());
+    mMapView->zoom((F32)mZoomSlider->getValue().asReal());
 
     // Enable/disable checkboxes depending on the zoom level
     // If above threshold level (i.e. low res) -> Disable all checkboxes
     // If under threshold level (i.e. high res) -> Enable all checkboxes
     bool enable = mMapView->showRegionInfo();
-    getChildView("people_chk")->setEnabled(enable);
-    getChildView("infohub_chk")->setEnabled(enable);
-    getChildView("telehub_chk")->setEnabled(enable);
-    getChildView("land_for_sale_chk")->setEnabled(enable);
-    getChildView("event_chk")->setEnabled(enable);
-    getChildView("events_mature_chk")->setEnabled(enable);
-    getChildView("events_adult_chk")->setEnabled(enable);
+    mPeopleCheck->setEnabled(enable);
+    mInfohubCheck->setEnabled(enable);
+    mTelehubCheck->setEnabled(enable);
+    mLandSaleCheck->setEnabled(enable);
+    mEventsCheck->setEnabled(enable);
+    mEventsMatureCheck->setEnabled(enable);
+    mEventsAdultCheck->setEnabled(enable);
 
     LLFloater::draw();
 }
@@ -576,7 +600,7 @@ void LLFloaterWorldMap::trackAvatar( const LLUUID& avatar_id, const std::string&
         // convenience.
         if(gAgent.isGodlike())
         {
-            getChild<LLUICtrl>("teleport_coordinate_z")->setValue(LLSD(200.f));
+            mTeleportCoordSpinZ->setValue(LLSD(200.f));
         }
         // Don't re-request info if we already have it or we won't have it in time to teleport
         if (mTrackedStatus != LLTracker::TRACKING_AVATAR || avatar_id != mTrackedAvatarID)
@@ -711,9 +735,9 @@ void LLFloaterWorldMap::trackLocation(const LLVector3d& pos_global)
 // enable/disable teleport destination coordinates
 void LLFloaterWorldMap::enableTeleportCoordsDisplay( bool enabled )
 {
-    childSetEnabled("teleport_coordinate_x", enabled );
-    childSetEnabled("teleport_coordinate_y", enabled );
-    childSetEnabled("teleport_coordinate_z", enabled );
+    mTeleportCoordSpinX->setEnabled(enabled);
+    mTeleportCoordSpinY->setEnabled(enabled);
+    mTeleportCoordSpinZ->setEnabled(enabled);
 }
 
 // update display of teleport destination coordinates - pos is in global coordinates
@@ -728,9 +752,9 @@ void LLFloaterWorldMap::updateTeleportCoordsDisplay( const LLVector3d& pos )
     F32 region_local_z = (F32)llclamp( pos.mdV[VZ], 0.0, (F64)REGION_HEIGHT_METERS );
 
     // write in the values
-    childSetValue("teleport_coordinate_x", region_local_x );
-    childSetValue("teleport_coordinate_y", region_local_y );
-    childSetValue("teleport_coordinate_z", region_local_z );
+    mTeleportCoordSpinX->setValue(region_local_x);
+    mTeleportCoordSpinY->setValue(region_local_y);
+    mTeleportCoordSpinZ->setValue(region_local_z);
 }
 
 void LLFloaterWorldMap::updateLocation()
@@ -757,7 +781,7 @@ void LLFloaterWorldMap::updateLocation()
                 mSetToUserPosition = false;
 
                 // Fill out the location field
-                getChild<LLUICtrl>("location")->setValue(agent_sim_name);
+                mLocationEditor->setValue(agent_sim_name);
 
                 // update the coordinate display with location of avatar in region
                 updateTeleportCoordsDisplay( agentPos );
@@ -790,7 +814,7 @@ void LLFloaterWorldMap::updateLocation()
             }
         }
 
-        getChild<LLUICtrl>("location")->setValue(sim_name);
+        mLocationEditor->setValue(sim_name);
 
         // refresh coordinate display to reflect where user clicked.
         LLVector3d coord_pos = LLTracker::getTrackedPositionGlobal();
@@ -825,17 +849,17 @@ void LLFloaterWorldMap::trackURL(const std::string& region_name, S32 x_coord, S3
     else
     {
         // fill in UI based on URL
-        gFloaterWorldMap->getChild<LLUICtrl>("location")->setValue(region_name);
+        mLocationEditor->setValue(region_name);
 
         // Save local coords to highlight position after region global
         // position is returned.
-        gFloaterWorldMap->mCompletingRegionPos.set(
+        mCompletingRegionPos.set(
                                                    (F32)x_coord, (F32)y_coord, (F32)z_coord);
 
         // pass sim name to combo box
-        gFloaterWorldMap->mCompletingRegionName = region_name;
+        mCompletingRegionName = region_name;
         LLWorldMapMessage::getInstance()->sendNamedRegionRequest(region_name);
-        LLStringUtil::toLower(gFloaterWorldMap->mCompletingRegionName);
+        LLStringUtil::toLower(mCompletingRegionName);
         LLWorldMap::getInstance()->setTrackingCommit();
     }
 }
@@ -1067,7 +1091,7 @@ void LLFloaterWorldMap::adjustZoomSliderBounds()
 
     F32 min_power = log(pixels_per_region/256.f)/log(2.f);
 
-    getChild<LLSliderCtrl>("zoom slider")->setMinValue(min_power);
+    mZoomSlider->setMinValue(min_power);
 }
 
 
@@ -1229,7 +1253,7 @@ void LLFloaterWorldMap::onLocationFocusChanged( LLFocusableElement* focus )
 void LLFloaterWorldMap::updateSearchEnabled()
 {
     if (childHasKeyboardFocus("location") &&
-        getChild<LLUICtrl>("location")->getValue().asString().length() > 0)
+        mLocationEditor->getValue().asString().length() > 0)
     {
         setDefaultBtn("DoSearch");
     }
@@ -1250,14 +1274,14 @@ void LLFloaterWorldMap::onLocationCommit()
     mCompletingRegionName = "";
     mLastRegionName = "";
 
-    std::string str = getChild<LLUICtrl>("location")->getValue().asString();
+    std::string str = mLocationEditor->getValue().asString();
 
     // Trim any leading and trailing spaces in the search target
     std::string saved_str = str;
     LLStringUtil::trim( str );
     if ( str != saved_str )
     {   // Set the value in the UI if any spaces were removed
-        getChild<LLUICtrl>("location")->setValue(str);
+        mLocationEditor->setValue(str);
     }
 
     // Don't try completing empty name (STORM-1427).
@@ -1287,11 +1311,11 @@ void LLFloaterWorldMap::onCoordinatesCommit()
         return;
     }
 
-    S32 x_coord = (S32)childGetValue("teleport_coordinate_x").asReal();
-    S32 y_coord = (S32)childGetValue("teleport_coordinate_y").asReal();
-    S32 z_coord = (S32)childGetValue("teleport_coordinate_z").asReal();
+    S32 x_coord = (S32)mTeleportCoordSpinX->getValue().asReal();
+    S32 y_coord = (S32)mTeleportCoordSpinY->getValue().asReal();
+    S32 z_coord = (S32)mTeleportCoordSpinZ->getValue().asReal();
 
-    const std::string region_name = childGetValue("location").asString();
+    const std::string region_name = mLocationEditor->getValue().asString();
 
     trackURL( region_name, x_coord, y_coord, z_coord );
 }
@@ -1420,7 +1444,7 @@ void LLFloaterWorldMap::teleport()
         && av_tracker.haveTrackingInfo() )
     {
         pos_global = av_tracker.getGlobalPos();
-        pos_global.mdV[VZ] = getChild<LLUICtrl>("teleport_coordinate_z")->getValue();
+        pos_global.mdV[VZ] = mTeleportCoordSpinZ->getValue();
     }
     else if ( LLTracker::TRACKING_LANDMARK == tracking_status)
     {
@@ -1654,7 +1678,7 @@ void LLFloaterWorldMap::onCommitSearchResult()
             pos_global.mdV[VY] += (F64)pos_local.mV[VY];
             pos_global.mdV[VZ] = (F64)pos_local.mV[VZ];
 
-            getChild<LLUICtrl>("location")->setValue(sim_name);
+            mLocationEditor->setValue(sim_name);
             trackLocation(pos_global);
             setDefaultBtn("Teleport");
             break;
diff --git a/indra/newview/llfloaterworldmap.h b/indra/newview/llfloaterworldmap.h
index 6765157e55..269b231e37 100644
--- a/indra/newview/llfloaterworldmap.h
+++ b/indra/newview/llfloaterworldmap.h
@@ -45,6 +45,11 @@ class LLItemInfo;
 class LLLineEditor;
 class LLTabContainer;
 class LLWorldMapView;
+class LLButton;
+class LLCheckBoxCtrl;
+class LLSliderCtrl;
+class LLSpinCtrl;
+class LLSearchEditor;
 
 class LLFloaterWorldMap : public LLFloater
 {
@@ -142,7 +147,6 @@ protected:
     void            buildLandmarkIDLists();
     void            flyToLandmark();
     void            teleportToLandmark();
-    void            setLandmarkVisited();
 
     void            buildAvatarIDList();
     void            flyToAvatar();
@@ -195,6 +199,30 @@ private:
     LLCtrlListInterface *   mListLandmarkCombo;
     LLCtrlListInterface *   mListSearchResults;
 
+    LLButton*               mTeleportButton = nullptr;
+    LLButton*               mShowDestinationButton = nullptr;
+    LLButton*               mCopySlurlButton = nullptr;
+    LLButton*               mGoHomeButton = nullptr;
+
+    LLCheckBoxCtrl*         mPeopleCheck = nullptr;
+    LLCheckBoxCtrl*         mInfohubCheck = nullptr;
+    LLCheckBoxCtrl*         mTelehubCheck = nullptr;
+    LLCheckBoxCtrl*         mLandSaleCheck = nullptr;
+    LLCheckBoxCtrl*         mEventsCheck = nullptr;
+    LLCheckBoxCtrl*         mEventsMatureCheck = nullptr;
+    LLCheckBoxCtrl*         mEventsAdultCheck = nullptr;
+
+    LLUICtrl*               mAvatarIcon = nullptr;
+    LLUICtrl*               mLandmarkIcon = nullptr;
+    LLUICtrl*               mLocationIcon = nullptr;
+
+    LLSearchEditor*         mLocationEditor = nullptr;
+    LLUICtrl*               mTeleportCoordSpinX = nullptr;
+    LLUICtrl*               mTeleportCoordSpinY = nullptr;
+    LLUICtrl*               mTeleportCoordSpinZ = nullptr;
+
+    LLSliderCtrl*           mZoomSlider = nullptr;
+
     boost::signals2::connection mTeleportFinishConnection;
 };
 

From 2d595bd00cde3c0501ce44b6ab2b11d53347828d Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Tue, 23 Jul 2024 21:42:20 -0400
Subject: [PATCH 16/30] Fix findChild calls during draw from LLFloaterSnapshot

---
 indra/newview/llfloatersnapshot.cpp | 9 +++++----
 indra/newview/llfloatersnapshot.h   | 1 +
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/indra/newview/llfloatersnapshot.cpp b/indra/newview/llfloatersnapshot.cpp
index e03b11e572..ddc567c029 100644
--- a/indra/newview/llfloatersnapshot.cpp
+++ b/indra/newview/llfloatersnapshot.cpp
@@ -192,7 +192,7 @@ void LLFloaterSnapshotBase::ImplBase::updateLayout(LLFloaterSnapshotBase* floate
         }
     }
 
-    bool use_freeze_frame = floaterp->getChild<LLUICtrl>("freeze_frame_check")->getValue().asBoolean();
+    bool use_freeze_frame = floaterp->mFreezeFrameCheck && floaterp->mFreezeFrameCheck->getValue().asBoolean();
 
     if (use_freeze_frame)
     {
@@ -720,7 +720,7 @@ void LLFloaterSnapshot::Impl::updateResolution(LLUICtrl* ctrl, void* data, bool
                 new_width = spanel->getTypedPreviewWidth();
                 new_height = spanel->getTypedPreviewHeight();
 
-                // Limit custom size for inventory snapshots to 512x512 px.
+                // Limit custom size for inventory snapshots to 2048x2048 px.
                 if (getActiveSnapshotType(view) == LLSnapshotModel::SNAPSHOT_TEXTURE)
                 {
                     new_width = llmin(new_width, MAX_TEXTURE_SIZE);
@@ -1002,8 +1002,9 @@ bool LLFloaterSnapshot::postBuild()
     getChild<LLUICtrl>("layer_types")->setValue("colors");
     getChildView("layer_types")->setEnabled(false);
 
-    getChild<LLUICtrl>("freeze_frame_check")->setValue(gSavedSettings.getBOOL("UseFreezeFrame"));
-    childSetCommitCallback("freeze_frame_check", ImplBase::onCommitFreezeFrame, this);
+    mFreezeFrameCheck = getChild<LLUICtrl>("freeze_frame_check");
+    mFreezeFrameCheck->setValue(gSavedSettings.getBOOL("UseFreezeFrame"));
+    mFreezeFrameCheck->setCommitCallback(&ImplBase::onCommitFreezeFrame, this);
 
     getChild<LLUICtrl>("auto_snapshot_check")->setValue(gSavedSettings.getBOOL("AutoSnapshot"));
     childSetCommitCallback("auto_snapshot_check", ImplBase::onClickAutoSnap, this);
diff --git a/indra/newview/llfloatersnapshot.h b/indra/newview/llfloatersnapshot.h
index ac5a472b03..6df851b839 100644
--- a/indra/newview/llfloatersnapshot.h
+++ b/indra/newview/llfloatersnapshot.h
@@ -72,6 +72,7 @@ protected:
     LLUICtrl* mThumbnailPlaceholder;
     LLUICtrl *mRefreshBtn, *mRefreshLabel;
     LLUICtrl *mSucceessLblPanel, *mFailureLblPanel;
+    LLUICtrl* mFreezeFrameCheck = nullptr;
 };
 
 class LLFloaterSnapshotBase::ImplBase

From b5491416a0d26261b90fd37edf462fe9b9e0ab36 Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Tue, 23 Jul 2024 21:43:09 -0400
Subject: [PATCH 17/30] Fix getChild calls during draw from
 LLFloaterIMSessionTab

---
 indra/newview/llfloaterimsessiontab.cpp | 4 ++--
 indra/newview/llfloaterimsessiontab.h   | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/indra/newview/llfloaterimsessiontab.cpp b/indra/newview/llfloaterimsessiontab.cpp
index a0b56b14f0..2eebb6cc64 100644
--- a/indra/newview/llfloaterimsessiontab.cpp
+++ b/indra/newview/llfloaterimsessiontab.cpp
@@ -262,6 +262,7 @@ bool LLFloaterIMSessionTab::postBuild()
 {
     bool result;
 
+    mContentsView = getChild<LLView>("contents_view");
     mBodyStack = getChild<LLLayoutStack>("main_stack");
     mParticipantListAndHistoryStack = getChild<LLLayoutStack>("im_panels");
 
@@ -861,7 +862,6 @@ void LLFloaterIMSessionTab::hideOrShowTitle()
 {
     const LLFloater::Params& default_params = LLFloater::getDefaultParams();
     S32 floater_header_size = default_params.header_height;
-    LLView* floater_contents = getChild<LLView>("contents_view");
 
     LLRect floater_rect = getLocalRect();
     S32 top_border_of_contents = floater_rect.mTop - (isTornOff()? floater_header_size : 0);
@@ -869,7 +869,7 @@ void LLFloaterIMSessionTab::hideOrShowTitle()
     LLRect contents_rect (0, top_border_of_contents, floater_rect.mRight, floater_rect.mBottom);
     mDragHandle->setShape(handle_rect);
     mDragHandle->setVisible(isTornOff());
-    floater_contents->setShape(contents_rect);
+    mContentsView->setShape(contents_rect);
 }
 
 void LLFloaterIMSessionTab::updateSessionName(const std::string& name)
diff --git a/indra/newview/llfloaterimsessiontab.h b/indra/newview/llfloaterimsessiontab.h
index 0a8502cfc5..29e10184b1 100644
--- a/indra/newview/llfloaterimsessiontab.h
+++ b/indra/newview/llfloaterimsessiontab.h
@@ -164,6 +164,7 @@ protected:
     LLConversationViewParticipant* createConversationViewParticipant(LLConversationItem* item);
 
     LLUUID mSessionID;
+    LLView* mContentsView;
     LLLayoutStack* mBodyStack;
     LLLayoutStack* mParticipantListAndHistoryStack;
     LLLayoutPanel* mParticipantListPanel;   // add the widgets to that see mConversationsListPanel

From 11448d490faeb0bb979f6296b97252548a9415a6 Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Wed, 24 Jul 2024 11:52:47 -0400
Subject: [PATCH 18/30] Fix findChild stutter during teleports

---
 indra/newview/llviewermenu.cpp | 75 ++++++++++++++++++++++++++--------
 1 file changed, 59 insertions(+), 16 deletions(-)

diff --git a/indra/newview/llviewermenu.cpp b/indra/newview/llviewermenu.cpp
index 2687938b35..4fcfe1a120 100644
--- a/indra/newview/llviewermenu.cpp
+++ b/indra/newview/llviewermenu.cpp
@@ -350,7 +350,10 @@ class LLMenuParcelObserver : public LLParcelObserver
 public:
     LLMenuParcelObserver();
     ~LLMenuParcelObserver();
-    virtual void changed();
+    void changed() override;
+private:
+    LLHandle<LLUICtrl> mLandBuyHandle;
+    LLHandle<LLUICtrl> mLandBuyPassHandle;
 };
 
 static LLMenuParcelObserver* gMenuParcelObserver = NULL;
@@ -359,6 +362,8 @@ static LLUIListener sUIListener;
 
 LLMenuParcelObserver::LLMenuParcelObserver()
 {
+    mLandBuyHandle = gMenuLand->getChild<LLMenuItemCallGL>("Land Buy")->getHandle();
+    mLandBuyPassHandle = gMenuLand->getChild<LLMenuItemCallGL>("Land Buy Pass")->getHandle();
     LLViewerParcelMgr::getInstance()->addObserver(this);
 }
 
@@ -372,18 +377,17 @@ void LLMenuParcelObserver::changed()
     LLParcel *parcel = LLViewerParcelMgr::getInstance()->getParcelSelection()->getParcel();
     if (gMenuLand && parcel)
     {
-        LLView* child = gMenuLand->findChild<LLView>("Land Buy Pass");
-        if (child)
-        {
-            child->setEnabled(LLPanelLandGeneral::enableBuyPass(NULL) && !(parcel->getOwnerID() == gAgent.getID()));
-        }
+	    if (!mLandBuyPassHandle.isDead())
+	    {
+	        LLParcel *parcel = LLViewerParcelMgr::getInstance()->getParcelSelection()->getParcel();
+	        static_cast<LLMenuItemCallGL*>(mLandBuyPassHandle.get())->setEnabled(LLPanelLandGeneral::enableBuyPass(NULL) && !(parcel->getOwnerID() == gAgent.getID()));
+	    }
 
-        child = gMenuLand->findChild<LLView>("Land Buy");
-        if (child)
-        {
-            bool buyable = enable_buy_land(NULL);
-            child->setEnabled(buyable);
-        }
+	    if (!mLandBuyHandle.isDead())
+	    {
+	        bool buyable = enable_buy_land(NULL);
+	        static_cast<LLMenuItemCallGL*>(mLandBuyHandle.get())->setEnabled(buyable);
+	    }
     }
 }
 
@@ -402,10 +406,34 @@ void initialize_menus();
 // Break up groups of more than 6 items with separators
 //-----------------------------------------------------------------------------
 
-void set_merchant_SLM_menu()
+void set_merchant_SLM_menu();
+
+class LLSLMMenuUpdater
+{
+public:
+    LLSLMMenuUpdater();
+    ~LLSLMMenuUpdater() = default;
+
+    void setMerchantMenu();
+    void checkMerchantStatus(bool force);
+
+private:
+    LLHandle<LLView> mMarketplaceListingsItem;
+};
+
+static LLSLMMenuUpdater* gSLMMenuUpdater = NULL;
+
+LLSLMMenuUpdater::LLSLMMenuUpdater()
+{
+    mMarketplaceListingsItem = gMenuHolder->getChild<LLView>("MarketplaceListings")->getHandle();
+}
+void LLSLMMenuUpdater::setMerchantMenu()
 {
     // All other cases (new merchant, not merchant, migrated merchant): show the new Marketplace Listings menu and enable the tool
-    gMenuHolder->getChild<LLView>("MarketplaceListings")->setVisible(true);
+    if(!mMarketplaceListingsItem.isDead())
+    {
+        mMarketplaceListingsItem.get()->setVisible(true);
+    }
     LLCommand* command = LLCommandManager::instance().getCommand("marketplacelistings");
     gToolBarView->enableCommand(command->id(), true);
 
@@ -422,7 +450,7 @@ void set_merchant_SLM_menu()
     }
 }
 
-void check_merchant_status(bool force)
+void LLSLMMenuUpdater::checkMerchantStatus(bool force)
 {
     if (force)
     {
@@ -430,7 +458,10 @@ void check_merchant_status(bool force)
         LLMarketplaceData::instance().setSLMStatus(MarketplaceStatusCodes::MARKET_PLACE_NOT_INITIALIZED);
     }
     // Hide SLM related menu item
-    gMenuHolder->getChild<LLView>("MarketplaceListings")->setVisible(false);
+    if(!mMarketplaceListingsItem.isDead())
+    {
+        mMarketplaceListingsItem.get()->setVisible(false);
+    }
 
     // Also disable the toolbar button for Marketplace Listings
     LLCommand* command = LLCommandManager::instance().getCommand("marketplacelistings");
@@ -440,6 +471,16 @@ void check_merchant_status(bool force)
     LLMarketplaceData::instance().initializeSLM(boost::bind(&set_merchant_SLM_menu));
 }
 
+void set_merchant_SLM_menu()
+{
+   if(gSLMMenuUpdater) gSLMMenuUpdater->setMerchantMenu();
+}
+
+void check_merchant_status(bool force)
+{
+   if(gSLMMenuUpdater) gSLMMenuUpdater->checkMerchantStatus(force);
+}
+
 void init_menus()
 {
     // Initialize actions
@@ -555,6 +596,8 @@ void init_menus()
     // Let land based option enable when parcel changes
     gMenuParcelObserver = new LLMenuParcelObserver();
 
+    gSLMMenuUpdater = new LLSLMMenuUpdater();
+
     gLoginMenuBarView = LLUICtrlFactory::getInstance()->createFromFile<LLMenuBarGL>("menu_login.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
     gLoginMenuBarView->arrangeAndClear();
     LLRect menuBarRect = gLoginMenuBarView->getRect();

From c8e988e1a16e9b6f7f8befaaf9752250dca25183 Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Wed, 24 Jul 2024 12:44:02 -0400
Subject: [PATCH 19/30] Fix excessive findChild calls when a docked control is
 open from LLDockControl::getAllowedRect

---
 indra/llui/lldockcontrol.cpp | 7 ++++++-
 indra/llui/lldockcontrol.h   | 1 +
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/indra/llui/lldockcontrol.cpp b/indra/llui/lldockcontrol.cpp
index bf0862e8a9..11dbad8c09 100644
--- a/indra/llui/lldockcontrol.cpp
+++ b/indra/llui/lldockcontrol.cpp
@@ -43,6 +43,8 @@ LLDockControl::LLDockControl(LLView* dockWidget, LLFloater* dockableFloater,
         mDockWidgetHandle = dockWidget->getHandle();
     }
 
+    mNonToolbarPanelHandle = mDockableFloater->getRootView()->getChild<LLView>("non_toolbar_panel")->getHandle();
+
     if (dockableFloater->isDocked())
     {
         on();
@@ -97,7 +99,10 @@ void LLDockControl::setDock(LLView* dockWidget)
 
 void LLDockControl::getAllowedRect(LLRect& rect)
 {
-    rect = mDockableFloater->getRootView()->getChild<LLView>("non_toolbar_panel")->getRect();
+    if(!mNonToolbarPanelHandle.isDead())
+    {
+        rect = mNonToolbarPanelHandle.get()->getRect();
+    }
 }
 
 void LLDockControl::repositionDockable()
diff --git a/indra/llui/lldockcontrol.h b/indra/llui/lldockcontrol.h
index fb0bf7d251..7e31330713 100644
--- a/indra/llui/lldockcontrol.h
+++ b/indra/llui/lldockcontrol.h
@@ -84,6 +84,7 @@ private:
     bool mDockWidgetVisible;
     DocAt mDockAt;
     LLHandle<LLView> mDockWidgetHandle;
+    LLHandle<LLView> mNonToolbarPanelHandle;
     LLRect mPrevDockRect;
     LLRect mRootRect;
     LLRect mFloaterRect;

From 24fb96c9af5cb2d566617a8bef827af29b1d8f58 Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Wed, 24 Jul 2024 12:45:06 -0400
Subject: [PATCH 20/30] Fix LLViewerEventRecorder triggering findChild events
 when it's disabled

---
 indra/llui/llviewereventrecorder.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/indra/llui/llviewereventrecorder.cpp b/indra/llui/llviewereventrecorder.cpp
index 1bf3e3c43b..e5e0545dad 100644
--- a/indra/llui/llviewereventrecorder.cpp
+++ b/indra/llui/llviewereventrecorder.cpp
@@ -98,6 +98,7 @@ void LLViewerEventRecorder::setMouseGlobalCoords(S32 x, S32 y) {
 }
 
 void LLViewerEventRecorder::updateMouseEventInfo(S32 local_x, S32 local_y, S32 global_x, S32 global_y, std::string mName) {
+    if (!logEvents) return;
 
   LLView * target_view = LLUI::getInstance()->resolvePath(LLUI::getInstance()->getRootView(), xui);
   if (! target_view) {
@@ -126,6 +127,8 @@ void LLViewerEventRecorder::updateMouseEventInfo(S32 local_x, S32 local_y, S32 g
 
 void LLViewerEventRecorder::logVisibilityChange(std::string xui, std::string name, bool visibility, std::string event_subtype) {
 
+    if (!logEvents) return;
+
   LLSD  event=LLSD::emptyMap();
 
   event.insert("event",LLSD(std::string("visibility")));
@@ -167,6 +170,7 @@ void LLViewerEventRecorder::update_xui(std::string xui) {
 
 void LLViewerEventRecorder::logKeyEvent(KEY key, MASK mask) {
 
+    if (!logEvents) return;
   // NOTE: Event recording only logs keydown events - the viewer itself hides keyup events at a fairly low level in the code and does not appear to care about them anywhere
 
   LLSD event = LLSD::emptyMap();

From 63d32e8b32b99d511c557f4fd390d974f3672ab7 Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Wed, 24 Jul 2024 12:58:01 -0400
Subject: [PATCH 21/30] Fix accidental memory leak from gSLMMenuUpdater

---
 indra/newview/llviewermenu.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/indra/newview/llviewermenu.cpp b/indra/newview/llviewermenu.cpp
index 4fcfe1a120..888b607bfb 100644
--- a/indra/newview/llviewermenu.cpp
+++ b/indra/newview/llviewermenu.cpp
@@ -2795,6 +2795,9 @@ class LLAdminOnSaveState: public view_listener_t
 //-----------------------------------------------------------------------------
 void cleanup_menus()
 {
+    delete gSLMMenuUpdater;
+    gSLMMenuUpdater = nullptr;
+
     delete gMenuParcelObserver;
     gMenuParcelObserver = NULL;
 
@@ -2811,7 +2814,7 @@ void cleanup_menus()
     gMenuAttachmentSelf = NULL;
 
     delete gMenuAttachmentOther;
-    gMenuAttachmentSelf = NULL;
+    gMenuAttachmentOther = NULL;
 
     delete gMenuLand;
     gMenuLand = NULL;

From 7e82c1de5242e7dacafe7d69abb753f6fe528e0f Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Wed, 24 Jul 2024 12:59:55 -0400
Subject: [PATCH 22/30] Fix performance floater getChild while drawing

---
 indra/newview/llfloaterperformance.cpp | 17 ++++++++++++-----
 indra/newview/llfloaterperformance.h   |  9 +++++++++
 2 files changed, 21 insertions(+), 5 deletions(-)

diff --git a/indra/newview/llfloaterperformance.cpp b/indra/newview/llfloaterperformance.cpp
index 3a633a7ff8..d5782accef 100644
--- a/indra/newview/llfloaterperformance.cpp
+++ b/indra/newview/llfloaterperformance.cpp
@@ -152,6 +152,13 @@ bool LLFloaterPerformance::postBuild()
     mStartAutotuneBtn->setCommitCallback(boost::bind(&LLFloaterPerformance::startAutotune, this));
     mStopAutotuneBtn->setCommitCallback(boost::bind(&LLFloaterPerformance::stopAutotune, this));
 
+    mCheckTuneContinous = mAutoadjustmentsPanel->getChild<LLCheckBoxCtrl>("AutoTuneContinuous");
+    mTextWIPDesc = mAutoadjustmentsPanel->getChild<LLTextBox>("wip_desc");
+    mTextDisplayDesc = mAutoadjustmentsPanel->getChild<LLTextBox>("display_desc");
+
+    mTextFPSLabel = getChild<LLTextBox>("fps_lbl");
+    mTextFPSValue = getChild<LLTextBox>("fps_value");
+
     gSavedPerAccountSettings.declareBOOL("HadEnabledAutoFPS", false, "User had enabled AutoFPS at least once", LLControlVariable::PERSIST_ALWAYS);
 
     return true;
@@ -512,7 +519,7 @@ void LLFloaterPerformance::setFPSText()
 {
     const S32 NUM_PERIODS = 50;
     S32 current_fps = (S32)llround(LLTrace::get_frame_recording().getPeriodMedianPerSec(LLStatViewer::FPS, NUM_PERIODS));
-    getChild<LLTextBox>("fps_value")->setValue(current_fps);
+    mTextFPSValue->setValue(current_fps);
 
     std::string fps_text = getString("fps_text");
     static LLCachedControl<bool> vsync_enabled(gSavedSettings, "RenderVSyncEnable", true);
@@ -521,7 +528,7 @@ void LLFloaterPerformance::setFPSText()
     {
         fps_text += getString("max_text");
     }
-    getChild<LLTextBox>("fps_lbl")->setValue(fps_text);
+    mTextFPSLabel->setValue(fps_text);
 }
 
 void LLFloaterPerformance::detachItem(const LLUUID& item_id)
@@ -722,10 +729,10 @@ void LLFloaterPerformance::updateAutotuneCtrls(bool autotune_enabled)
     static LLCachedControl<bool> auto_tune_locked(gSavedSettings, "AutoTuneLock");
     mStartAutotuneBtn->setEnabled(!autotune_enabled && !auto_tune_locked);
     mStopAutotuneBtn->setEnabled(autotune_enabled && !auto_tune_locked);
-    getChild<LLCheckBoxCtrl>("AutoTuneContinuous")->setEnabled(!autotune_enabled || (autotune_enabled && auto_tune_locked));
+    mCheckTuneContinous->setEnabled(!autotune_enabled || (autotune_enabled && auto_tune_locked));
 
-    getChild<LLTextBox>("wip_desc")->setVisible(autotune_enabled && !auto_tune_locked);
-    getChild<LLTextBox>("display_desc")->setVisible(LLPerfStats::tunables.vsyncEnabled);
+    mTextWIPDesc->setVisible(autotune_enabled && !auto_tune_locked);
+    mTextDisplayDesc->setVisible(LLPerfStats::tunables.vsyncEnabled);
 }
 
 void LLFloaterPerformance::enableAutotuneWarning()
diff --git a/indra/newview/llfloaterperformance.h b/indra/newview/llfloaterperformance.h
index 089a508455..a7100eb350 100644
--- a/indra/newview/llfloaterperformance.h
+++ b/indra/newview/llfloaterperformance.h
@@ -30,7 +30,9 @@
 #include "lllistcontextmenu.h"
 
 class LLCharacter;
+class LLCheckBoxCtrl;
 class LLNameListCtrl;
+class LLTextBox;
 
 class LLFloaterPerformance : public LLFloater
 {
@@ -90,6 +92,13 @@ private:
     LLButton* mStartAutotuneBtn;
     LLButton* mStopAutotuneBtn;
 
+    LLTextBox* mTextWIPDesc = nullptr;
+    LLTextBox* mTextDisplayDesc = nullptr;
+    LLTextBox* mTextFPSLabel = nullptr;
+    LLTextBox* mTextFPSValue = nullptr;
+
+    LLCheckBoxCtrl* mCheckTuneContinous = nullptr;
+
     LLListContextMenu* mContextMenu;
 
     LLTimer* mUpdateTimer;

From 0a420e7d9ab54162a04472c756a3994b6597445d Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Wed, 24 Jul 2024 17:45:01 -0400
Subject: [PATCH 23/30] Fix find child during draw in texture picker

---
 indra/newview/lltexturectrl.cpp | 4 ++--
 indra/newview/lltexturectrl.h   | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/indra/newview/lltexturectrl.cpp b/indra/newview/lltexturectrl.cpp
index e154777aef..35057a910a 100644
--- a/indra/newview/lltexturectrl.cpp
+++ b/indra/newview/lltexturectrl.cpp
@@ -558,6 +558,7 @@ bool LLFloaterTexturePicker::postBuild()
     mResolutionLabel = getChild<LLTextBox>("size_lbl");
     mResolutionWarning = getChild<LLTextBox>("over_limit_lbl");
 
+    mPreviewWidget = getChild<LLView>("preview_widget");
 
     mDefaultBtn = getChild<LLButton>("Default");
     mNoneBtn = getChild<LLButton>("None");
@@ -653,7 +654,6 @@ void LLFloaterTexturePicker::draw()
     bool valid_dims = updateImageStats();
 
     // if we're inactive, gray out "apply immediate" checkbox
-    getChildView("show_folders_check")->setEnabled(mActive && mCanApplyImmediately && !mNoCopyTextureSelected);
     mSelectBtn->setEnabled(mActive && mCanApply && valid_dims);
     mPipetteBtn->setEnabled(mActive);
     mPipetteBtn->setValue(LLToolMgr::getInstance()->getCurrentTool() == LLToolPipette::getInstance());
@@ -731,7 +731,7 @@ void LLFloaterTexturePicker::draw()
         }
 
         // Border
-        LLRect border = getChildView("preview_widget")->getRect();
+        LLRect border = mPreviewWidget->getRect();
         gl_rect_2d( border, LLColor4::black, false );
 
 
diff --git a/indra/newview/lltexturectrl.h b/indra/newview/lltexturectrl.h
index 3c6cff4eaa..df5e763139 100644
--- a/indra/newview/lltexturectrl.h
+++ b/indra/newview/lltexturectrl.h
@@ -437,6 +437,7 @@ protected:
     LLButton*           mPipetteBtn;
     LLButton*           mSelectBtn;
     LLButton*           mCancelBtn;
+    LLView*             mPreviewWidget = nullptr;
 
 private:
     bool mCanApply;

From 70f332d02e687c2c3d4806ccda0e1dcd8bde1232 Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Wed, 24 Jul 2024 18:47:24 -0400
Subject: [PATCH 24/30] Fix findChild during draw in the parcel/region
 environment panel

---
 indra/newview/llfloaterland.cpp       |   8 +-
 indra/newview/llfloaterregioninfo.cpp |  12 +-
 indra/newview/llpanelenvironment.cpp  | 180 ++++++++++++++------------
 indra/newview/llpanelenvironment.h    |  32 +++++
 4 files changed, 142 insertions(+), 90 deletions(-)

diff --git a/indra/newview/llfloaterland.cpp b/indra/newview/llfloaterland.cpp
index 41b6025e0f..aebadb36ae 100644
--- a/indra/newview/llfloaterland.cpp
+++ b/indra/newview/llfloaterland.cpp
@@ -3331,10 +3331,10 @@ bool LLPanelLandEnvironment::postBuild()
     if (!LLPanelEnvironmentInfo::postBuild())
         return false;
 
-    getChild<LLUICtrl>(BTN_USEDEFAULT)->setLabelArg("[USEDEFAULT]", getString(STR_LABEL_USEREGION));
-    getChild<LLUICtrl>(CHK_ALLOWOVERRIDE)->setVisible(false);
-    getChild<LLUICtrl>(PNL_REGION_MSG)->setVisible(false);
-    getChild<LLUICtrl>(PNL_ENVIRONMENT_ALTITUDES)->setVisible(true);
+    mBtnUseDefault->setLabelArg("[USEDEFAULT]", getString(STR_LABEL_USEREGION));
+    mCheckAllowOverride->setVisible(false);
+    mPanelEnvRegionMsg->setVisible(false);
+    mPanelEnvAltitudes->setVisible(true);
 
     return true;
 }
diff --git a/indra/newview/llfloaterregioninfo.cpp b/indra/newview/llfloaterregioninfo.cpp
index 52eddcfc67..fc6abf4bfe 100644
--- a/indra/newview/llfloaterregioninfo.cpp
+++ b/indra/newview/llfloaterregioninfo.cpp
@@ -4201,11 +4201,11 @@ bool LLPanelRegionEnvironment::postBuild()
     if (!LLPanelEnvironmentInfo::postBuild())
         return false;
 
-    getChild<LLUICtrl>(BTN_USEDEFAULT)->setLabelArg("[USEDEFAULT]", getString(STR_LABEL_USEDEFAULT));
-    getChild<LLUICtrl>(CHK_ALLOWOVERRIDE)->setVisible(true);
-    getChild<LLUICtrl>(PNL_ENVIRONMENT_ALTITUDES)->setVisible(true);
+    mBtnUseDefault->setLabelArg("[USEDEFAULT]", getString(STR_LABEL_USEDEFAULT));
+    mCheckAllowOverride->setVisible(true);
+    mPanelEnvAltitudes->setVisible(true);
 
-    getChild<LLUICtrl>(CHK_ALLOWOVERRIDE)->setCommitCallback([this](LLUICtrl *, const LLSD &value){ onChkAllowOverride(value.asBoolean()); });
+    mCheckAllowOverride->setCommitCallback([this](LLUICtrl *, const LLSD &value){ onChkAllowOverride(value.asBoolean()); });
 
     mCommitConnect = estate_info.setCommitCallback(boost::bind(&LLPanelRegionEnvironment::refreshFromEstate, this));
     return true;
@@ -4227,7 +4227,7 @@ void LLPanelRegionEnvironment::refresh()
 
     LLPanelEnvironmentInfo::refresh();
 
-    getChild<LLUICtrl>(CHK_ALLOWOVERRIDE)->setValue(mAllowOverride);
+    mCheckAllowOverride->setValue(mAllowOverride);
 }
 
 bool LLPanelRegionEnvironment::refreshFromRegion(LLViewerRegion* region)
@@ -4293,7 +4293,7 @@ bool LLPanelRegionEnvironment::confirmUpdateEstateEnvironment(const LLSD& notifi
 
     case 1:
         mAllowOverride = mAllowOverrideRestore;
-        getChild<LLUICtrl>(CHK_ALLOWOVERRIDE)->setValue(mAllowOverride);
+        mCheckAllowOverride->setValue(mAllowOverride);
         break;
     default:
         break;
diff --git a/indra/newview/llpanelenvironment.cpp b/indra/newview/llpanelenvironment.cpp
index a706e339ea..0c8bbbf308 100644
--- a/indra/newview/llpanelenvironment.cpp
+++ b/indra/newview/llpanelenvironment.cpp
@@ -41,6 +41,7 @@
 #include "llfloater.h"
 #include "llfloaterreg.h"
 #include "llfloatereditextdaycycle.h"
+#include "lliconctrl.h"
 #include "llmultisliderctrl.h"
 #include "llnotificationsutil.h"
 #include "llsettingsvo.h"
@@ -109,10 +110,7 @@ const U32 LLPanelEnvironmentInfo::DIRTY_FLAG_MASK(
         LLPanelEnvironmentInfo::DIRTY_FLAG_DAYOFFSET |
         LLPanelEnvironmentInfo::DIRTY_FLAG_ALTITUDES);
 
-const U32 ALTITUDE_SLIDER_COUNT = 3;
 const F32 ALTITUDE_DEFAULT_HEIGHT_STEP = 1000;
-const U32 ALTITUDE_MARKERS_COUNT = 3;
-const U32 ALTITUDE_PREFIXERS_COUNT = 5;
 
 const std::string slider_marker_base = "mark";
 
@@ -167,24 +165,58 @@ LLPanelEnvironmentInfo::~LLPanelEnvironmentInfo()
 
 bool LLPanelEnvironmentInfo::postBuild()
 {
+    mIconGround = getChild<LLIconCtrl>(ICN_GROUND);
+    mIconWater = getChild<LLIconCtrl>(ICN_WATER);
 
-    getChild<LLUICtrl>(BTN_USEDEFAULT)->setCommitCallback([this](LLUICtrl *, const LLSD &){ onBtnDefault(); });
-    getChild<LLUICtrl>(BTN_SELECTINV)->setCommitCallback([this](LLUICtrl *, const LLSD &){ onBtnSelect(); });
-    getChild<LLUICtrl>(BTN_EDIT)->setCommitCallback([this](LLUICtrl *, const LLSD &){ onBtnEdit(); });
-    getChild<LLUICtrl>(BTN_RST_ALTITUDES)->setCommitCallback([this](LLUICtrl *, const LLSD &){ onBtnRstAltitudes(); });
+    mPanelEnvAltitudes = getChild<LLUICtrl>(PNL_ENVIRONMENT_ALTITUDES);
+    mPanelEnvConfig = getChild<LLUICtrl>(PNL_SETTINGS);
+    mPanelEnvButtons = getChild <LLUICtrl>(PNL_BUTTONS);
+    mPanelEnvDisabled = getChild<LLUICtrl>(PNL_DISABLED);
+    mPanelEnvRegionMsg = getChild<LLUICtrl>(PNL_REGION_MSG);
 
-    getChild<LLUICtrl>(SLD_DAYLENGTH)->setCommitCallback([this](LLUICtrl *, const LLSD &value) { onSldDayLengthChanged((F32)value.asReal()); });
-    getChild<LLSliderCtrl>(SLD_DAYLENGTH)->setSliderMouseUpCallback([this](LLUICtrl *, const LLSD &) { onDayLenOffsetMouseUp(); });
-    getChild<LLSliderCtrl>(SLD_DAYLENGTH)->setSliderEditorCommitCallback([this](LLUICtrl *, const LLSD &) { onDayLenOffsetMouseUp(); });
-    getChild<LLUICtrl>(SLD_DAYOFFSET)->setCommitCallback([this](LLUICtrl *, const LLSD &value) { onSldDayOffsetChanged((F32)value.asReal()); });
-    getChild<LLSliderCtrl>(SLD_DAYOFFSET)->setSliderMouseUpCallback([this](LLUICtrl *, const LLSD &) { onDayLenOffsetMouseUp(); });
-    getChild<LLSliderCtrl>(SLD_DAYOFFSET)->setSliderEditorCommitCallback([this](LLUICtrl *, const LLSD &) { onDayLenOffsetMouseUp(); });
+    mEnvironmentDisabledText = getChild<LLTextBox>(TXT_DISABLED);
+    mLabelApparentTime = getChild<LLTextBox>(LBL_TIMEOFDAY);
 
-    getChild<LLMultiSliderCtrl>(SLD_ALTITUDES)->setCommitCallback([this](LLUICtrl *cntrl, const LLSD &value) { onAltSliderCallback(cntrl, value); });
-    getChild<LLMultiSliderCtrl>(SLD_ALTITUDES)->setSliderMouseUpCallback([this](LLUICtrl *, const LLSD &) { onAltSliderMouseUp(); });
+    mBtnUseDefault = getChild<LLButton>(BTN_USEDEFAULT);
+    mBtnUseDefault->setCommitCallback([this](LLUICtrl *, const LLSD &){ onBtnDefault(); });
+
+    mBtnSelectInv = getChild<LLButton>(BTN_SELECTINV);
+    mBtnSelectInv->setCommitCallback([this](LLUICtrl *, const LLSD &){ onBtnSelect(); });
+
+    mBtnEdit = getChild<LLButton>(BTN_EDIT);
+    mBtnEdit->setCommitCallback([this](LLUICtrl *, const LLSD &){ onBtnEdit(); });
+
+    mBtnResetAltitudes = getChild<LLButton>(BTN_RST_ALTITUDES);
+    mBtnResetAltitudes->setCommitCallback([this](LLUICtrl *, const LLSD &){ onBtnRstAltitudes(); });
+
+    mCheckAllowOverride = getChild<LLCheckBoxCtrl>(CHK_ALLOWOVERRIDE);
+
+    mSliderDayLength = getChild<LLSliderCtrl>(SLD_DAYLENGTH);
+    mSliderDayLength->setCommitCallback([this](LLUICtrl *, const LLSD &value) { onSldDayLengthChanged((F32)value.asReal()); });
+    mSliderDayLength->setSliderMouseUpCallback([this](LLUICtrl *, const LLSD &) { onDayLenOffsetMouseUp(); });
+    mSliderDayLength->setSliderEditorCommitCallback([this](LLUICtrl *, const LLSD &) { onDayLenOffsetMouseUp(); });
+
+    mSliderDayOffset = getChild<LLSliderCtrl>(SLD_DAYOFFSET);
+    mSliderDayOffset->setCommitCallback([this](LLUICtrl *, const LLSD &value) { onSldDayOffsetChanged((F32)value.asReal()); });
+    mSliderDayOffset->setSliderMouseUpCallback([this](LLUICtrl *, const LLSD &) { onDayLenOffsetMouseUp(); });
+    mSliderDayOffset->setSliderEditorCommitCallback([this](LLUICtrl *, const LLSD &) { onDayLenOffsetMouseUp(); });
+
+    mMultiSliderAltitudes = getChild<LLMultiSliderCtrl>(SLD_ALTITUDES);
+    mMultiSliderAltitudes->setCommitCallback([this](LLUICtrl *cntrl, const LLSD &value) { onAltSliderCallback(cntrl, value); });
+    mMultiSliderAltitudes->setSliderMouseUpCallback([this](LLUICtrl *, const LLSD &) { onAltSliderMouseUp(); });
 
     mChangeMonitor = LLEnvironment::instance().setEnvironmentChanged([this](LLEnvironment::EnvSelection_t env, S32 version) { onEnvironmentChanged(env, version); });
 
+    for (U32 idx = 0; idx < ALTITUDE_MARKERS_COUNT; idx++)
+    {
+        mAltitudeMarkers[idx] = findChild<LLUICtrl>(slider_marker_base + llformat("%u", idx));
+    }
+
+    for (U32 idx = 0; idx < ALTITUDE_PREFIXERS_COUNT; idx++)
+    {
+        mAltitudePrefixers[idx] = findChild<LLSettingsDropTarget>("sdt_" + alt_prefixes[idx]);
+    }
+
     for (U32 idx = 0; idx < ALTITUDE_SLIDER_COUNT; idx++)
     {
         LLSettingsDropTarget* drop_target = findChild<LLSettingsDropTarget>("sdt_" + alt_prefixes[idx]);
@@ -262,8 +294,8 @@ void LLPanelEnvironmentInfo::refresh()
     if (dayoffset.value() > 12.0f)
         dayoffset -= F32Hours(24.0);
 
-    getChild<LLSliderCtrl>(SLD_DAYLENGTH)->setValue(daylength.value());
-    getChild<LLSliderCtrl>(SLD_DAYOFFSET)->setValue(dayoffset.value());
+    mSliderDayLength->setValue(daylength.value());
+    mSliderDayOffset->setValue(dayoffset.value());
 
     udpateApparentTimeOfDay();
 
@@ -273,40 +305,39 @@ void LLPanelEnvironmentInfo::refresh()
 
     if (altitudes.size() > 0)
     {
-        LLMultiSliderCtrl *sld = getChild<LLMultiSliderCtrl>(SLD_ALTITUDES);
-        sld->clear();
+        mMultiSliderAltitudes->clear();
 
         for (S32 idx = 0; idx < ALTITUDE_SLIDER_COUNT; ++idx)
         {
             // make sure values are in range, server is supposed to validate them,
             // but issues happen, try to fix values in such case
-            F32 altitude = llclamp(altitudes[idx + 1], sld->getMinValue(), sld->getMaxValue());
-            bool res = sld->addSlider(altitude, alt_sliders[idx]);
+            F32 altitude = llclamp(altitudes[idx + 1], mMultiSliderAltitudes->getMinValue(), mMultiSliderAltitudes->getMaxValue());
+            bool res = mMultiSliderAltitudes->addSlider(altitude, alt_sliders[idx]);
             if (!res)
             {
                 LL_WARNS_ONCE("ENVPANEL") << "Failed to validate altitude from server for parcel id" << getParcelId() << LL_ENDL;
                 // Find a spot to insert altitude.
                 // Assuming everything alright with slider, we should find new place in 11 steps top (step 25m, no overlap 100m)
-                F32 alt_step = (altitude > (sld->getMaxValue() / 2)) ? -sld->getIncrement() : sld->getIncrement();
+                F32 alt_step = (altitude > (mMultiSliderAltitudes->getMaxValue() / 2)) ? -mMultiSliderAltitudes->getIncrement() : mMultiSliderAltitudes->getIncrement();
                 for (U32 i = 0; i < 30; i++)
                 {
                     altitude += alt_step;
-                    if (altitude > sld->getMaxValue())
+                    if (altitude > mMultiSliderAltitudes->getMaxValue())
                     {
-                        altitude = sld->getMinValue();
+                        altitude = mMultiSliderAltitudes->getMinValue();
                     }
-                    else if (altitude < sld->getMinValue())
+                    else if (altitude < mMultiSliderAltitudes->getMinValue())
                     {
-                        altitude = sld->getMaxValue();
+                        altitude = mMultiSliderAltitudes->getMaxValue();
                     }
-                    res = sld->addSlider(altitude, alt_sliders[idx]);
+                    res = mMultiSliderAltitudes->addSlider(altitude, alt_sliders[idx]);
                     if (res) break;
                 }
             }
             if (res)
             {
                 // slider has some auto correction that might have kicked in
-                altitude = sld->getSliderValue(alt_sliders[idx]);
+                altitude = mMultiSliderAltitudes->getSliderValue(alt_sliders[idx]);
             }
             else
             {
@@ -316,12 +347,12 @@ void LLPanelEnvironmentInfo::refresh()
             updateAltLabel(alt_prefixes[idx], idx + 2, altitude);
             mAltitudes[alt_sliders[idx]] = AltitudeData(idx + 2, idx, altitude);
         }
-        if (sld->getCurNumSliders() != ALTITUDE_SLIDER_COUNT)
+        if (mMultiSliderAltitudes->getCurNumSliders() != ALTITUDE_SLIDER_COUNT)
         {
             LL_WARNS("ENVPANEL") << "Failed to add altitude sliders!" << LL_ENDL;
         }
         readjustAltLabels();
-        sld->resetCurSlider();
+        mMultiSliderAltitudes->resetCurSlider();
     }
 
     updateAltLabel(alt_prefixes[3], 1, 0); // ground
@@ -455,77 +486,75 @@ bool LLPanelEnvironmentInfo::setControlsEnabled(bool enabled)
     if (mNoEnvironment || (!LLEnvironment::instance().isExtendedEnvironmentEnabled() && !isRegion()))
     {
         is_unavailable = true;
-        getChild<LLTextBox>(TXT_DISABLED)->setText(getString(STR_LEGACY));
+        mEnvironmentDisabledText->setText(getString(STR_LEGACY));
     }
     else if (mNoSelection)
     {
         is_unavailable = true;
-        getChild<LLTextBox>(TXT_DISABLED)->setText(getString(STR_NO_PARCEL));
+        mEnvironmentDisabledText->setText(getString(STR_NO_PARCEL));
     }
     else if (mCrossRegion)
     {
         is_unavailable = true;
-        getChild<LLTextBox>(TXT_DISABLED)->setText(getString(STR_CROSS_REGION));
+        mEnvironmentDisabledText->setText(getString(STR_CROSS_REGION));
     }
     else if (!isRegion() && !mAllowOverride)
     {
         is_unavailable = true;
-        getChild<LLTextBox>(TXT_DISABLED)->setText(getString(STR_DISALLOWED));
+        mEnvironmentDisabledText->setText(getString(STR_DISALLOWED));
     }
     else if (!is_bigenough)
     {
         is_unavailable = true;
-        getChild<LLTextBox>(TXT_DISABLED)->setText(getString(STR_TOO_SMALL));
+        mEnvironmentDisabledText->setText(getString(STR_TOO_SMALL));
     }
 
     if (is_unavailable)
     {
-        getChild<LLUICtrl>(PNL_SETTINGS)->setVisible(false);
-        getChild<LLUICtrl>(PNL_BUTTONS)->setVisible(false);
-        getChild<LLUICtrl>(PNL_DISABLED)->setVisible(true);
-        getChild<LLUICtrl>(PNL_ENVIRONMENT_ALTITUDES)->setVisible(false);
-        getChild<LLUICtrl>(PNL_REGION_MSG)->setVisible(false);
+        mPanelEnvConfig->setVisible(false);
+        mPanelEnvButtons->setVisible(false);
+        mPanelEnvDisabled->setVisible(true);
+        mPanelEnvAltitudes->setVisible(false);
+        mPanelEnvRegionMsg->setVisible(false);
         updateEditFloater(mCurrentEnvironment, false);
 
         return false;
     }
-    getChild<LLUICtrl>(PNL_SETTINGS)->setVisible(true);
-    getChild<LLUICtrl>(PNL_BUTTONS)->setVisible(true);
-    getChild<LLUICtrl>(PNL_DISABLED)->setVisible(false);
-    getChild<LLUICtrl>(PNL_REGION_MSG)->setVisible(isRegion());
+    mPanelEnvConfig->setVisible(true);
+    mPanelEnvButtons->setVisible(true);
+    mPanelEnvDisabled->setVisible(false);
+    mPanelEnvRegionMsg->setVisible(isRegion());
 
-    getChild<LLUICtrl>(PNL_ENVIRONMENT_ALTITUDES)->setVisible(LLEnvironment::instance().isExtendedEnvironmentEnabled());
-    getChild<LLUICtrl>(BTN_RST_ALTITUDES)->setVisible(isRegion());
+    mPanelEnvAltitudes->setVisible(LLEnvironment::instance().isExtendedEnvironmentEnabled());
+    mBtnResetAltitudes->setVisible(isRegion());
 
     bool can_enable = enabled && !is_legacy && mCurrentEnvironment && (mCurEnvVersion != INVALID_PARCEL_ENVIRONMENT_VERSION);
-    getChild<LLUICtrl>(BTN_SELECTINV)->setEnabled(can_enable);
-    getChild<LLUICtrl>(BTN_USEDEFAULT)->setEnabled(can_enable);
-    getChild<LLUICtrl>(BTN_EDIT)->setEnabled(can_enable);
-    getChild<LLUICtrl>(SLD_DAYLENGTH)->setEnabled(can_enable);
-    getChild<LLUICtrl>(SLD_DAYOFFSET)->setEnabled(can_enable);
-    getChild<LLUICtrl>(SLD_ALTITUDES)->setEnabled(can_enable && isRegion());
-    getChild<LLUICtrl>(ICN_GROUND)->setColor((can_enable && isRegion()) ? LLColor4::white : LLColor4::grey % 0.8f);
-    getChild<LLUICtrl>(ICN_WATER)->setColor((can_enable && isRegion()) ? LLColor4::white : LLColor4::grey % 0.8f);
-    getChild<LLUICtrl>(BTN_RST_ALTITUDES)->setEnabled(can_enable && isRegion());
-    getChild<LLUICtrl>(PNL_ENVIRONMENT_ALTITUDES)->setEnabled(can_enable);
-    getChild<LLUICtrl>(CHK_ALLOWOVERRIDE)->setEnabled(can_enable && isRegion());
+    mBtnSelectInv->setEnabled(can_enable);
+    mBtnUseDefault->setEnabled(can_enable);
+    mBtnEdit->setEnabled(can_enable);
+    mSliderDayLength->setEnabled(can_enable);
+    mSliderDayOffset->setEnabled(can_enable);
+    mMultiSliderAltitudes->setEnabled(can_enable && isRegion());
+    mIconGround->setColor((can_enable && isRegion()) ? LLColor4::white : LLColor4::grey % 0.8f);
+    mIconWater->setColor((can_enable && isRegion()) ? LLColor4::white : LLColor4::grey % 0.8f);
+    mBtnResetAltitudes->setEnabled(can_enable && isRegion());
+    mPanelEnvAltitudes->setEnabled(can_enable);
+    mCheckAllowOverride->setEnabled(can_enable && isRegion());
 
     for (U32 idx = 0; idx < ALTITUDE_MARKERS_COUNT; idx++)
     {
-        LLUICtrl* marker = findChild<LLUICtrl>(slider_marker_base + llformat("%u", idx));
-        if (marker)
+        if (mAltitudeMarkers[idx])
         {
             static LLColor4 marker_color(0.75f, 0.75f, 0.75f, 1.f);
-            marker->setColor((can_enable && isRegion()) ? marker_color : marker_color % 0.3f);
+            mAltitudeMarkers[idx]->setColor((can_enable && isRegion()) ? marker_color : marker_color % 0.3f);
         }
     }
 
     for (U32 idx = 0; idx < ALTITUDE_PREFIXERS_COUNT; idx++)
     {
-        LLSettingsDropTarget* drop_target = findChild<LLSettingsDropTarget>("sdt_" + alt_prefixes[idx]);
-        if (drop_target)
+        if (mAltitudePrefixers[idx])
         {
-            drop_target->setDndEnabled(can_enable);
+            mAltitudePrefixers[idx]->setDndEnabled(can_enable);
         }
     }
 
@@ -544,13 +573,7 @@ void LLPanelEnvironmentInfo::clearDirtyFlag(U32 flag)
 
 void LLPanelEnvironmentInfo::updateAltLabel(const std::string &alt_prefix, U32 sky_index, F32 alt_value)
 {
-    LLMultiSliderCtrl *sld = findChild<LLMultiSliderCtrl>(SLD_ALTITUDES);
-    if (!sld)
-    {
-        LL_WARNS() << "Failed to find slider " << SLD_ALTITUDES << LL_ENDL;
-        return;
-    }
-    LLRect sld_rect = sld->getRect();
+    LLRect sld_rect = mMultiSliderAltitudes->getRect();
     S32 sld_range = sld_rect.getHeight();
     S32 sld_bottom = sld_rect.mBottom;
     S32 sld_offset = sld_rect.getWidth(); // Roughly identical to thumb's width in slider.
@@ -596,14 +619,11 @@ void LLPanelEnvironmentInfo::readjustAltLabels()
     // Very simple "adjust after the fact" method
     // Note: labels can be in any order
 
-    LLMultiSliderCtrl *sld = findChild<LLMultiSliderCtrl>(SLD_ALTITUDES);
-    if (!sld) return;
-
     LLView* view_midle = NULL;
     U32 midle_ind = 0;
     S32 shift_up = 0;
     S32 shift_down = 0;
-    LLRect sld_rect = sld->getRect();
+    LLRect sld_rect = mMultiSliderAltitudes->getRect();
 
     // Find the middle one
     for (U32 i = 0; i < ALTITUDE_SLIDER_COUNT; i++)
@@ -907,10 +927,10 @@ void LLPanelEnvironmentInfo::udpateApparentTimeOfDay()
 
     if ((!mCurrentEnvironment) || (mCurrentEnvironment->mDayLength.value() < 1.0) || (mCurrentEnvironment->mDayOffset.value() < 1.0))
     {
-        getChild<LLUICtrl>(LBL_TIMEOFDAY)->setVisible(false);
+        mLabelApparentTime->setVisible(false);
         return;
     }
-    getChild<LLUICtrl>(LBL_TIMEOFDAY)->setVisible(true);
+    mLabelApparentTime->setVisible(true);
 
     S32Seconds now((S32)LLDate::now().secondsSinceEpoch());
 
@@ -932,10 +952,10 @@ void LLPanelEnvironmentInfo::udpateApparentTimeOfDay()
     std::string lblminute(((minutesofhour.value() < 10) ? "0" : "") + LLSD(minutesofhour.value()).asString());
 
 
-    getChild<LLUICtrl>(LBL_TIMEOFDAY)->setTextArg("[HH]", LLSD(hourofday.value()).asString());
-    getChild<LLUICtrl>(LBL_TIMEOFDAY)->setTextArg("[MM]", lblminute);
-    getChild<LLUICtrl>(LBL_TIMEOFDAY)->setTextArg("[AP]", std::string(am_pm ? "PM" : "AM"));
-    getChild<LLUICtrl>(LBL_TIMEOFDAY)->setTextArg("[PRC]", LLSD((S32)(100 * perc)).asString());
+    mLabelApparentTime->setTextArg("[HH]", LLSD(hourofday.value()).asString());
+    mLabelApparentTime->setTextArg("[MM]", lblminute);
+    mLabelApparentTime->setTextArg("[AP]", std::string(am_pm ? "PM" : "AM"));
+    mLabelApparentTime->setTextArg("[PRC]", LLSD((S32)(100 * perc)).asString());
 
 }
 
diff --git a/indra/newview/llpanelenvironment.h b/indra/newview/llpanelenvironment.h
index b478142987..0544524ece 100644
--- a/indra/newview/llpanelenvironment.h
+++ b/indra/newview/llpanelenvironment.h
@@ -39,6 +39,7 @@
 #include "llestateinfomodel.h"
 
 class LLViewerRegion;
+class LLIconCtrl;
 
 class LLPanelEnvironmentInfo : public LLPanel
 {
@@ -63,6 +64,10 @@ public:
 protected:
     LOG_CLASS(LLPanelEnvironmentInfo);
 
+    static constexpr U32 ALTITUDE_SLIDER_COUNT = 3;
+    static constexpr U32 ALTITUDE_MARKERS_COUNT = 3;
+    static constexpr U32 ALTITUDE_PREFIXERS_COUNT = 5;
+
     static const std::string    BTN_SELECTINV;
     static const std::string    BTN_EDIT;
     static const std::string    BTN_USEDEFAULT;
@@ -168,6 +173,33 @@ protected:
     altitudes_data_t                mAltitudes;
     S32                             mCurEnvVersion; // used to filter duplicate callbacks/refreshes
 
+    LLUICtrl* mPanelEnvAltitudes = nullptr;
+    LLUICtrl* mPanelEnvConfig = nullptr;
+    LLUICtrl* mPanelEnvButtons = nullptr;
+    LLUICtrl* mPanelEnvDisabled = nullptr;
+    LLUICtrl* mPanelEnvRegionMsg = nullptr;
+
+    LLButton* mBtnSelectInv = nullptr;
+    LLButton* mBtnEdit = nullptr;
+    LLButton* mBtnUseDefault = nullptr;
+    LLButton* mBtnResetAltitudes = nullptr;
+
+    LLMultiSliderCtrl* mMultiSliderAltitudes = nullptr;
+
+    LLSliderCtrl* mSliderDayLength = nullptr;
+    LLSliderCtrl* mSliderDayOffset = nullptr;
+
+    LLTextBox* mEnvironmentDisabledText = nullptr;
+    LLTextBox* mLabelApparentTime = nullptr;
+
+    LLCheckBoxCtrl* mCheckAllowOverride = nullptr;
+
+    LLIconCtrl* mIconGround = nullptr;
+    LLIconCtrl* mIconWater = nullptr;
+
+    std::array<LLUICtrl*, ALTITUDE_MARKERS_COUNT> mAltitudeMarkers;
+    std::array<LLSettingsDropTarget*, ALTITUDE_PREFIXERS_COUNT> mAltitudePrefixers;
+
 protected:
     typedef boost::signals2::connection connection_t;
 

From e3deb8340a5f2e5b1c997e66042f3515f33f5cea Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Wed, 24 Jul 2024 19:30:29 -0400
Subject: [PATCH 25/30] Fix excessive findChild calls during about land floater
 draw

---
 indra/newview/llfloaterland.cpp       | 256 +++++++++++++-------------
 indra/newview/llfloaterland.h         |  18 +-
 indra/newview/llfloaterregioninfo.cpp |   1 -
 indra/newview/llpanelland.cpp         |  76 ++++----
 indra/newview/llpanelland.h           |  21 ++-
 5 files changed, 197 insertions(+), 175 deletions(-)

diff --git a/indra/newview/llfloaterland.cpp b/indra/newview/llfloaterland.cpp
index aebadb36ae..bec76fe5e4 100644
--- a/indra/newview/llfloaterland.cpp
+++ b/indra/newview/llfloaterland.cpp
@@ -2443,19 +2443,34 @@ LLPanelLandAccess::LLPanelLandAccess(LLParcelSelectionHandle& parcel)
 
 bool LLPanelLandAccess::postBuild()
 {
-    childSetCommitCallback("public_access", onCommitPublicAccess, this);
-    childSetCommitCallback("limit_payment", onCommitAny, this);
-    childSetCommitCallback("limit_age_verified", onCommitAny, this);
-    childSetCommitCallback("GroupCheck", onCommitGroupCheck, this);
-    childSetCommitCallback("PassCheck", onCommitAny, this);
-    childSetCommitCallback("pass_combo", onCommitAny, this);
-    childSetCommitCallback("PriceSpin", onCommitAny, this);
-    childSetCommitCallback("HoursSpin", onCommitAny, this);
+    mPaymentInfoCheck = getChild<LLUICtrl>("limit_payment");
+    mPaymentInfoCheck->setCommitCallback(onCommitAny, this);
+    mAgeVerifiedCheck = getChild<LLUICtrl>("limit_age_verified");
+    mAgeVerifiedCheck->setCommitCallback(onCommitAny, this);
+    mTemporaryPassCheck = getChild<LLUICtrl>("PassCheck");
+    mTemporaryPassCheck->setCommitCallback(onCommitAny, this);
+    mPublicAccessCheck = getChild<LLUICtrl>("public_access");
+    mPublicAccessCheck->setCommitCallback(onCommitPublicAccess, this);
+    mGroupAccessCheck = getChild<LLUICtrl>("GroupCheck");
+    mGroupAccessCheck->setCommitCallback(onCommitGroupCheck, this);
+    mTemporaryPassCombo = getChild<LLComboBox>("pass_combo");
+    mGroupAccessCheck->setCommitCallback(onCommitAny, this);
+    mTemporaryPassPriceSpin = getChild<LLUICtrl>("PriceSpin");
+    mGroupAccessCheck->setCommitCallback(onCommitAny, this);
+    mTemporaryPassHourSpin = getChild<LLUICtrl>("HoursSpin");
+    mGroupAccessCheck->setCommitCallback(onCommitAny, this);
 
-    childSetAction("add_allowed", boost::bind(&LLPanelLandAccess::onClickAddAccess, this));
-    childSetAction("remove_allowed", onClickRemoveAccess, this);
-    childSetAction("add_banned", boost::bind(&LLPanelLandAccess::onClickAddBanned, this));
-    childSetAction("remove_banned", onClickRemoveBanned, this);
+    mAllowText = getChild<LLUICtrl>("AllowedText");
+    mBanText = getChild<LLUICtrl>("BanCheck");
+
+    mBtnAddAllowed = getChild<LLButton>("add_allowed");
+    mBtnAddAllowed->setCommitCallback(boost::bind(&LLPanelLandAccess::onClickAddAccess, this));
+    mBtnRemoveAllowed = getChild<LLButton>("remove_allowed");
+    mBtnRemoveAllowed->setCommitCallback(boost::bind(&LLPanelLandAccess::onClickRemoveAccess, this));
+    mBtnAddBanned = getChild<LLButton>("add_banned");
+    mBtnAddBanned->setCommitCallback(boost::bind(&LLPanelLandAccess::onClickAddBanned, this));
+    mBtnRemoveBanned = getChild<LLButton>("remove_banned");
+    mBtnRemoveBanned->setCommitCallback(boost::bind(&LLPanelLandAccess::onClickRemoveBanned, this));
 
     mListAccess = getChild<LLNameListCtrl>("AccessList");
     if (mListAccess)
@@ -2494,17 +2509,17 @@ void LLPanelLandAccess::refresh()
 
         if (parcel->getRegionAllowAccessOverride())
         {
-            getChild<LLUICtrl>("public_access")->setValue(public_access);
-            getChild<LLUICtrl>("GroupCheck")->setValue(use_group);
+            mPublicAccessCheck->setValue(public_access);
+            mGroupAccessCheck->setValue(use_group);
         }
         else
         {
-            getChild<LLUICtrl>("public_access")->setValue(true);
-            getChild<LLUICtrl>("GroupCheck")->setValue(false);
+            mPublicAccessCheck->setValue(true);
+            mGroupAccessCheck->setValue(false);
         }
         std::string group_name;
         gCacheName->getGroupName(parcel->getGroupID(), group_name);
-        getChild<LLUICtrl>("GroupCheck")->setLabelArg("[GROUP]", group_name );
+        mGroupAccessCheck->setLabelArg("[GROUP]", group_name );
 
         // Allow list
         if (mListAccess)
@@ -2513,11 +2528,11 @@ void LLPanelLandAccess::refresh()
             mListAccess->clearSortOrder();
             mListAccess->deleteAllItems();
             auto count = parcel->mAccessList.size();
-            getChild<LLUICtrl>("AllowedText")->setTextArg("[COUNT]", llformat("%d",count));
-            getChild<LLUICtrl>("AllowedText")->setTextArg("[MAX]", llformat("%d",PARCEL_MAX_ACCESS_LIST));
+            mAllowText->setTextArg("[COUNT]", llformat("%d", count));
+            mAllowText->setTextArg("[MAX]", llformat("%d",PARCEL_MAX_ACCESS_LIST));
 
-            getChild<LLUICtrl>("AccessList")->setToolTipArg(LLStringExplicit("[LISTED]"), llformat("%d",count));
-            getChild<LLUICtrl>("AccessList")->setToolTipArg(LLStringExplicit("[MAX]"), llformat("%d",PARCEL_MAX_ACCESS_LIST));
+            mListAccess->setToolTipArg(LLStringExplicit("[LISTED]"), llformat("%d",count));
+            mListAccess->setToolTipArg(LLStringExplicit("[MAX]"), llformat("%d",PARCEL_MAX_ACCESS_LIST));
 
             for (LLAccessEntry::map::const_iterator cit = parcel->mAccessList.begin();
                  cit != parcel->mAccessList.end(); ++cit)
@@ -2561,11 +2576,11 @@ void LLPanelLandAccess::refresh()
             mListBanned->clearSortOrder();
             mListBanned->deleteAllItems();
             auto count = parcel->mBanList.size();
-            getChild<LLUICtrl>("BanCheck")->setTextArg("[COUNT]", llformat("%d",count));
-            getChild<LLUICtrl>("BanCheck")->setTextArg("[MAX]", llformat("%d",PARCEL_MAX_ACCESS_LIST));
+            mBanText->setTextArg("[COUNT]", llformat("%d",count));
+            mBanText->setTextArg("[MAX]", llformat("%d",PARCEL_MAX_ACCESS_LIST));
 
-            getChild<LLUICtrl>("BannedList")->setToolTipArg(LLStringExplicit("[LISTED]"), llformat("%d",count));
-            getChild<LLUICtrl>("BannedList")->setToolTipArg(LLStringExplicit("[MAX]"), llformat("%d",PARCEL_MAX_ACCESS_LIST));
+            mListBanned->setToolTipArg(LLStringExplicit("[LISTED]"), llformat("%d",count));
+            mListBanned->setToolTipArg(LLStringExplicit("[MAX]"), llformat("%d",PARCEL_MAX_ACCESS_LIST));
 
             for (LLAccessEntry::map::const_iterator cit = parcel->mBanList.begin();
                  cit != parcel->mBanList.end(); ++cit)
@@ -2622,75 +2637,74 @@ void LLPanelLandAccess::refresh()
 
         if(parcel->getRegionDenyAnonymousOverride())
         {
-            getChild<LLUICtrl>("limit_payment")->setValue(true);
-            getChild<LLUICtrl>("limit_payment")->setLabelArg("[ESTATE_PAYMENT_LIMIT]", getString("access_estate_defined") );
+            mPaymentInfoCheck->setValue(true);
+            mPaymentInfoCheck->setLabelArg("[ESTATE_PAYMENT_LIMIT]", getString("access_estate_defined") );
         }
         else
         {
-            getChild<LLUICtrl>("limit_payment")->setValue((parcel->getParcelFlag(PF_DENY_ANONYMOUS)));
-            getChild<LLUICtrl>("limit_payment")->setLabelArg("[ESTATE_PAYMENT_LIMIT]", std::string() );
+            mPaymentInfoCheck->setValue((parcel->getParcelFlag(PF_DENY_ANONYMOUS)));
+            mPaymentInfoCheck->setLabelArg("[ESTATE_PAYMENT_LIMIT]", std::string() );
         }
         if(parcel->getRegionDenyAgeUnverifiedOverride())
         {
-            getChild<LLUICtrl>("limit_age_verified")->setValue(true);
-            getChild<LLUICtrl>("limit_age_verified")->setLabelArg("[ESTATE_AGE_LIMIT]", getString("access_estate_defined") );
+            mAgeVerifiedCheck->setValue(true);
+            mAgeVerifiedCheck->setLabelArg("[ESTATE_AGE_LIMIT]", getString("access_estate_defined") );
         }
         else
         {
-            getChild<LLUICtrl>("limit_age_verified")->setValue((parcel->getParcelFlag(PF_DENY_AGEUNVERIFIED)));
-            getChild<LLUICtrl>("limit_age_verified")->setLabelArg("[ESTATE_AGE_LIMIT]", std::string() );
+            mAgeVerifiedCheck->setValue((parcel->getParcelFlag(PF_DENY_AGEUNVERIFIED)));
+            mAgeVerifiedCheck->setLabelArg("[ESTATE_AGE_LIMIT]", std::string() );
         }
 
         bool use_pass = parcel->getParcelFlag(PF_USE_PASS_LIST);
-        getChild<LLUICtrl>("PassCheck")->setValue(use_pass);
-        LLCtrlSelectionInterface* passcombo = childGetSelectionInterface("pass_combo");
-        if (passcombo)
+        mTemporaryPassCheck->setValue(use_pass);
+        if (mTemporaryPassCombo)
         {
             if (public_access || !use_pass)
             {
-                passcombo->selectByValue("anyone");
+                mTemporaryPassCombo->selectByValue("anyone");
             }
         }
 
         S32 pass_price = parcel->getPassPrice();
-        getChild<LLUICtrl>("PriceSpin")->setValue((F32)pass_price );
+        mTemporaryPassPriceSpin->setValue((F32)pass_price);
 
         F32 pass_hours = parcel->getPassHours();
-        getChild<LLUICtrl>("HoursSpin")->setValue(pass_hours );
+        mTemporaryPassHourSpin->setValue(pass_hours);
     }
     else
     {
-        getChild<LLUICtrl>("public_access")->setValue(false);
-        getChild<LLUICtrl>("limit_payment")->setValue(false);
-        getChild<LLUICtrl>("limit_age_verified")->setValue(false);
-        getChild<LLUICtrl>("GroupCheck")->setValue(false);
-        getChild<LLUICtrl>("GroupCheck")->setLabelArg("[GROUP]", LLStringUtil::null );
-        getChild<LLUICtrl>("PassCheck")->setValue(false);
-        getChild<LLUICtrl>("PriceSpin")->setValue((F32)PARCEL_PASS_PRICE_DEFAULT);
-        getChild<LLUICtrl>("HoursSpin")->setValue(PARCEL_PASS_HOURS_DEFAULT );
-        getChild<LLUICtrl>("AccessList")->setToolTipArg(LLStringExplicit("[LISTED]"), llformat("%d",0));
-        getChild<LLUICtrl>("AccessList")->setToolTipArg(LLStringExplicit("[MAX]"), llformat("%d",0));
-        getChild<LLUICtrl>("BannedList")->setToolTipArg(LLStringExplicit("[LISTED]"), llformat("%d",0));
-        getChild<LLUICtrl>("BannedList")->setToolTipArg(LLStringExplicit("[MAX]"), llformat("%d",0));
+        mPublicAccessCheck->setValue(false);
+        mPaymentInfoCheck->setValue(false);
+        mAgeVerifiedCheck->setValue(false);
+        mGroupAccessCheck->setValue(false);
+        mGroupAccessCheck->setLabelArg("[GROUP]", LLStringUtil::null );
+        mTemporaryPassCheck->setValue(false);
+        mTemporaryPassPriceSpin->setValue((F32)PARCEL_PASS_PRICE_DEFAULT);
+        mTemporaryPassHourSpin->setValue(PARCEL_PASS_HOURS_DEFAULT );
+        mListAccess->setToolTipArg(LLStringExplicit("[LISTED]"), llformat("%d",0));
+        mListAccess->setToolTipArg(LLStringExplicit("[MAX]"), llformat("%d",0));
+        mListBanned->setToolTipArg(LLStringExplicit("[LISTED]"), llformat("%d",0));
+        mListBanned->setToolTipArg(LLStringExplicit("[MAX]"), llformat("%d",0));
     }
 }
 
 void LLPanelLandAccess::refresh_ui()
 {
-    getChildView("public_access")->setEnabled(false);
-    getChildView("limit_payment")->setEnabled(false);
-    getChildView("limit_age_verified")->setEnabled(false);
-    getChildView("GroupCheck")->setEnabled(false);
-    getChildView("PassCheck")->setEnabled(false);
-    getChildView("pass_combo")->setEnabled(false);
-    getChildView("PriceSpin")->setEnabled(false);
-    getChildView("HoursSpin")->setEnabled(false);
-    getChildView("AccessList")->setEnabled(false);
-    getChildView("BannedList")->setEnabled(false);
-    getChildView("add_allowed")->setEnabled(false);
-    getChildView("remove_allowed")->setEnabled(false);
-    getChildView("add_banned")->setEnabled(false);
-    getChildView("remove_banned")->setEnabled(false);
+    mPublicAccessCheck->setEnabled(false);
+    mPaymentInfoCheck->setEnabled(false);
+    mAgeVerifiedCheck->setEnabled(false);
+    mGroupAccessCheck->setEnabled(false);
+    mTemporaryPassCheck->setEnabled(false);
+    mTemporaryPassCombo->setEnabled(false);
+    mTemporaryPassPriceSpin->setEnabled(false);
+    mTemporaryPassHourSpin->setEnabled(false);
+    mListAccess->setEnabled(false);
+    mListBanned->setEnabled(false);
+    mBtnAddAllowed->setEnabled(false);
+    mBtnRemoveAllowed->setEnabled(false);
+    mBtnAddBanned->setEnabled(false);
+    mBtnRemoveBanned->setEnabled(false);
 
     LLParcel *parcel = mParcel->getParcel();
     if (parcel && !gDisconnected)
@@ -2703,73 +2717,64 @@ void LLPanelLandAccess::refresh_ui()
             can_manage_allowed = LLViewerParcelMgr::isParcelModifiableByAgent(parcel, GP_LAND_MANAGE_ALLOWED);
         }
 
-        getChildView("public_access")->setEnabled(can_manage_allowed);
-        bool public_access = getChild<LLUICtrl>("public_access")->getValue().asBoolean();
+        mPublicAccessCheck->setEnabled(can_manage_allowed);
+        bool public_access = mPublicAccessCheck->getValue().asBoolean();
         if (public_access)
         {
             bool override = false;
             if(parcel->getRegionDenyAnonymousOverride())
             {
                 override = true;
-                getChildView("limit_payment")->setEnabled(false);
+                mPaymentInfoCheck->setEnabled(false);
             }
             else
             {
-                getChildView("limit_payment")->setEnabled(can_manage_allowed);
+                mPaymentInfoCheck->setEnabled(can_manage_allowed);
             }
             if(parcel->getRegionDenyAgeUnverifiedOverride())
             {
                 override = true;
-                getChildView("limit_age_verified")->setEnabled(false);
+                mAgeVerifiedCheck->setEnabled(false);
             }
             else
             {
-                getChildView("limit_age_verified")->setEnabled(can_manage_allowed);
+                mAgeVerifiedCheck->setEnabled(can_manage_allowed);
             }
-            if (override)
-            {
-                getChildView("Only Allow")->setToolTip(getString("estate_override"));
-            }
-            else
-            {
-                getChildView("Only Allow")->setToolTip(std::string());
-            }
-            getChildView("PassCheck")->setEnabled(false);
-            getChildView("pass_combo")->setEnabled(false);
-            getChildView("AccessList")->setEnabled(false);
+            mTemporaryPassCheck->setEnabled(false);
+            mTemporaryPassCombo->setEnabled(false);
+            mListAccess->setEnabled(false);
         }
         else
         {
-            getChildView("limit_payment")->setEnabled(false);
-            getChildView("limit_age_verified")->setEnabled(false);
+            mPaymentInfoCheck->setEnabled(false);
+            mAgeVerifiedCheck->setEnabled(false);
 
-
-            bool sell_passes = getChild<LLUICtrl>("PassCheck")->getValue().asBoolean();
-            getChildView("PassCheck")->setEnabled(can_manage_allowed);
+            bool sell_passes = mTemporaryPassCheck->getValue().asBoolean();
+            mTemporaryPassCheck->setEnabled(can_manage_allowed);
             if (sell_passes)
             {
-                getChildView("pass_combo")->setEnabled(can_manage_allowed);
-                getChildView("PriceSpin")->setEnabled(can_manage_allowed);
-                getChildView("HoursSpin")->setEnabled(can_manage_allowed);
+                mTemporaryPassCombo->setEnabled(can_manage_allowed);
+                mTemporaryPassPriceSpin->setEnabled(can_manage_allowed);
+                mTemporaryPassHourSpin->setEnabled(can_manage_allowed);
             }
         }
         std::string group_name;
         if (gCacheName->getGroupName(parcel->getGroupID(), group_name))
         {
-            bool can_allow_groups = !public_access || (public_access && (getChild<LLUICtrl>("limit_payment")->getValue().asBoolean() ^ getChild<LLUICtrl>("limit_age_verified")->getValue().asBoolean()));
-            getChildView("GroupCheck")->setEnabled(can_manage_allowed && can_allow_groups);
+            bool can_allow_groups = !public_access || (public_access && (mPaymentInfoCheck->getValue().asBoolean() ^ mAgeVerifiedCheck->getValue().asBoolean()));
+            mGroupAccessCheck->setEnabled(can_manage_allowed && can_allow_groups);
         }
-        getChildView("AccessList")->setEnabled(can_manage_allowed);
+        mListAccess->setEnabled(can_manage_allowed);
         auto allowed_list_count = parcel->mAccessList.size();
-        getChildView("add_allowed")->setEnabled(can_manage_allowed && allowed_list_count < PARCEL_MAX_ACCESS_LIST);
+        mBtnAddAllowed->setEnabled(can_manage_allowed && allowed_list_count < PARCEL_MAX_ACCESS_LIST);
         bool has_selected = (mListAccess && mListAccess->getSelectionInterface()->getFirstSelectedIndex() >= 0);
-        getChildView("remove_allowed")->setEnabled(can_manage_allowed && has_selected);
+        mBtnRemoveAllowed->setEnabled(can_manage_allowed && has_selected);
 
-        getChildView("BannedList")->setEnabled(can_manage_banned);
+        mListBanned->setEnabled(can_manage_banned);
         auto banned_list_count = parcel->mBanList.size();
-        getChildView("add_banned")->setEnabled(can_manage_banned && banned_list_count < PARCEL_MAX_ACCESS_LIST);
+        mBtnAddBanned->setEnabled(can_manage_banned && banned_list_count < PARCEL_MAX_ACCESS_LIST);
         has_selected = (mListBanned && mListBanned->getSelectionInterface()->getFirstSelectedIndex() >= 0);
-        getChildView("remove_banned")->setEnabled(can_manage_banned && has_selected);
+        mBtnRemoveBanned->setEnabled(can_manage_banned && has_selected);
     }
 }
 
@@ -2783,7 +2788,7 @@ void LLPanelLandAccess::refreshNames()
     {
         gCacheName->getGroupName(parcel->getGroupID(), group_name);
     }
-    getChild<LLUICtrl>("GroupCheck")->setLabelArg("[GROUP]", group_name);
+    mGroupAccessCheck->setLabelArg("[GROUP]", group_name);
 }
 
 
@@ -2817,9 +2822,9 @@ void LLPanelLandAccess::onCommitGroupCheck(LLUICtrl *ctrl, void *userdata)
         return;
     }
 
-    bool use_pass_list = !self->getChild<LLUICtrl>("public_access")->getValue().asBoolean();
-    bool use_access_group = self->getChild<LLUICtrl>("GroupCheck")->getValue().asBoolean();
-    LLCtrlSelectionInterface* passcombo = self->childGetSelectionInterface("pass_combo");
+    bool use_pass_list = !self->mPublicAccessCheck->getValue().asBoolean();
+    bool use_access_group = self->mGroupAccessCheck->getValue().asBoolean();
+    LLCtrlSelectionInterface* passcombo = self->mTemporaryPassCombo;
     if (passcombo)
     {
         if (use_access_group && use_pass_list)
@@ -2846,8 +2851,8 @@ void LLPanelLandAccess::onCommitAny(LLUICtrl *ctrl, void *userdata)
     }
 
     // Extract data from UI
-    bool public_access = self->getChild<LLUICtrl>("public_access")->getValue().asBoolean();
-    bool use_access_group = self->getChild<LLUICtrl>("GroupCheck")->getValue().asBoolean();
+    bool public_access = self->mPublicAccessCheck->getValue().asBoolean();
+    bool use_access_group = self->mGroupAccessCheck->getValue().asBoolean();
     if (use_access_group)
     {
         std::string group_name;
@@ -2864,14 +2869,14 @@ void LLPanelLandAccess::onCommitAny(LLUICtrl *ctrl, void *userdata)
     if (public_access)
     {
         use_access_list = false;
-        limit_payment = self->getChild<LLUICtrl>("limit_payment")->getValue().asBoolean();
-        limit_age_verified = self->getChild<LLUICtrl>("limit_age_verified")->getValue().asBoolean();
+        limit_payment = self->mPaymentInfoCheck->getValue().asBoolean();
+        limit_age_verified = self->mAgeVerifiedCheck->getValue().asBoolean();
     }
     else
     {
         use_access_list = true;
-        use_pass_list = self->getChild<LLUICtrl>("PassCheck")->getValue().asBoolean();
-        LLCtrlSelectionInterface* passcombo = self->childGetSelectionInterface("pass_combo");
+        use_pass_list = self->mTemporaryPassCheck->getValue().asBoolean();
+        LLCtrlSelectionInterface* passcombo = self->mTemporaryPassCombo;
         if (passcombo)
         {
             if (use_access_group && use_pass_list)
@@ -2884,8 +2889,8 @@ void LLPanelLandAccess::onCommitAny(LLUICtrl *ctrl, void *userdata)
         }
     }
 
-    S32 pass_price = llfloor((F32)self->getChild<LLUICtrl>("PriceSpin")->getValue().asReal());
-    F32 pass_hours = (F32)self->getChild<LLUICtrl>("HoursSpin")->getValue().asReal();
+    S32 pass_price = llfloor((F32)self->mTemporaryPassPriceSpin->getValue().asReal());
+    F32 pass_hours = (F32)self->mTemporaryPassHourSpin->getValue().asReal();
 
     // Push data into current parcel
     parcel->setParcelFlag(PF_USE_ACCESS_GROUP,  use_access_group);
@@ -2907,10 +2912,9 @@ void LLPanelLandAccess::onCommitAny(LLUICtrl *ctrl, void *userdata)
 
 void LLPanelLandAccess::onClickAddAccess()
 {
-    LLView * button = findChild<LLButton>("add_allowed");
     LLFloater * root_floater = gFloaterView->getParentFloater(this);
     LLFloaterAvatarPicker* picker = LLFloaterAvatarPicker::show(
-        boost::bind(&LLPanelLandAccess::callbackAvatarCBAccess, this, _1), false, false, false, root_floater->getName(), button);
+        boost::bind(&LLPanelLandAccess::callbackAvatarCBAccess, this, _1), false, false, false, root_floater->getName(), mBtnAddAllowed);
     if (picker)
     {
         root_floater->addDependentFloater(picker);
@@ -2938,16 +2942,14 @@ void LLPanelLandAccess::callbackAvatarCBAccess(const uuid_vec_t& ids)
     }
 }
 
-// static
-void LLPanelLandAccess::onClickRemoveAccess(void* data)
+void LLPanelLandAccess::onClickRemoveAccess()
 {
-    LLPanelLandAccess* panelp = (LLPanelLandAccess*)data;
-    if (panelp && panelp->mListAccess)
+    if (mListAccess)
     {
-        LLParcel* parcel = panelp->mParcel->getParcel();
+        LLParcel* parcel = mParcel->getParcel();
         if (parcel)
         {
-            std::vector<LLScrollListItem*> names = panelp->mListAccess->getAllSelected();
+            std::vector<LLScrollListItem*> names = mListAccess->getAllSelected();
             for (std::vector<LLScrollListItem*>::iterator iter = names.begin();
                  iter != names.end(); )
             {
@@ -2956,18 +2958,16 @@ void LLPanelLandAccess::onClickRemoveAccess(void* data)
                 parcel->removeFromAccessList(agent_id);
             }
             LLViewerParcelMgr::getInstance()->sendParcelAccessListUpdate(AL_ACCESS);
-            panelp->refresh();
+            refresh();
         }
     }
 }
 
-// static
 void LLPanelLandAccess::onClickAddBanned()
 {
-    LLView * button = findChild<LLButton>("add_banned");
     LLFloater * root_floater = gFloaterView->getParentFloater(this);
     LLFloaterAvatarPicker* picker = LLFloaterAvatarPicker::show(
-        boost::bind(&LLPanelLandAccess::callbackAvatarCBBanned, this, _1), true, false, false, root_floater->getName(), button);
+        boost::bind(&LLPanelLandAccess::callbackAvatarCBBanned, this, _1), true, false, false, root_floater->getName(), mBtnAddBanned);
     if (picker)
     {
         root_floater->addDependentFloater(picker);
@@ -3014,16 +3014,14 @@ void LLPanelLandAccess::callbackAvatarCBBanned2(const uuid_vec_t& ids, S32 durat
     }
 }
 
-// static
-void LLPanelLandAccess::onClickRemoveBanned(void* data)
+void LLPanelLandAccess::onClickRemoveBanned()
 {
-    LLPanelLandAccess* panelp = (LLPanelLandAccess*)data;
-    if (panelp && panelp->mListBanned)
+    if (mListBanned)
     {
-        LLParcel* parcel = panelp->mParcel->getParcel();
+        LLParcel* parcel = mParcel->getParcel();
         if (parcel)
         {
-            std::vector<LLScrollListItem*> names = panelp->mListBanned->getAllSelected();
+            std::vector<LLScrollListItem*> names = mListBanned->getAllSelected();
             for (std::vector<LLScrollListItem*>::iterator iter = names.begin();
                  iter != names.end(); )
             {
@@ -3032,7 +3030,7 @@ void LLPanelLandAccess::onClickRemoveBanned(void* data)
                 parcel->removeFromBanList(agent_id);
             }
             LLViewerParcelMgr::getInstance()->sendParcelAccessListUpdate(AL_BAN);
-            panelp->refresh();
+            refresh();
         }
     }
 }
diff --git a/indra/newview/llfloaterland.h b/indra/newview/llfloaterland.h
index 3560304566..95f6a44a94 100644
--- a/indra/newview/llfloaterland.h
+++ b/indra/newview/llfloaterland.h
@@ -375,13 +375,13 @@ public:
     static void onCommitPublicAccess(LLUICtrl* ctrl, void *userdata);
     static void onCommitAny(LLUICtrl* ctrl, void *userdata);
     static void onCommitGroupCheck(LLUICtrl* ctrl, void *userdata);
-    static void onClickRemoveAccess(void*);
-    static void onClickRemoveBanned(void*);
 
     virtual bool postBuild();
 
     void onClickAddAccess();
     void onClickAddBanned();
+    void onClickRemoveAccess();
+    void onClickRemoveBanned();
     void callbackAvatarCBBanned(const uuid_vec_t& ids);
     void callbackAvatarCBBanned2(const uuid_vec_t& ids, S32 duration);
     void callbackAvatarCBAccess(const uuid_vec_t& ids);
@@ -389,6 +389,20 @@ public:
 protected:
     LLNameListCtrl*     mListAccess;
     LLNameListCtrl*     mListBanned;
+    LLUICtrl*           mAllowText = nullptr;
+    LLUICtrl*           mBanText = nullptr;
+    LLUICtrl*           mPublicAccessCheck = nullptr;
+    LLUICtrl*           mGroupAccessCheck = nullptr;
+    LLUICtrl*           mPaymentInfoCheck = nullptr;
+    LLUICtrl*           mAgeVerifiedCheck = nullptr;
+    LLUICtrl*           mTemporaryPassCheck = nullptr;
+    LLComboBox*         mTemporaryPassCombo = nullptr;
+    LLUICtrl*           mTemporaryPassPriceSpin = nullptr;
+    LLUICtrl*           mTemporaryPassHourSpin = nullptr;
+    LLButton*           mBtnAddAllowed = nullptr;
+    LLButton*           mBtnRemoveAllowed = nullptr;
+    LLButton*           mBtnAddBanned = nullptr;
+    LLButton*           mBtnRemoveBanned = nullptr;
 
     LLSafeHandle<LLParcelSelection>&    mParcel;
 };
diff --git a/indra/newview/llfloaterregioninfo.cpp b/indra/newview/llfloaterregioninfo.cpp
index fc6abf4bfe..cc9aca1338 100644
--- a/indra/newview/llfloaterregioninfo.cpp
+++ b/indra/newview/llfloaterregioninfo.cpp
@@ -2331,7 +2331,6 @@ void LLPanelEstateInfo::refresh()
     // Disable access restriction controls if they make no sense.
     bool public_access = ("estate_public_access" == getChild<LLUICtrl>("externally_visible_radio")->getValue().asString());
 
-    getChildView("Only Allow")->setEnabled(public_access);
     getChildView("limit_payment")->setEnabled(public_access);
     getChildView("limit_age_verified")->setEnabled(public_access);
     getChildView("limit_bots")->setEnabled(public_access);
diff --git a/indra/newview/llpanelland.cpp b/indra/newview/llpanelland.cpp
index 3e22374294..07f4a710db 100644
--- a/indra/newview/llpanelland.cpp
+++ b/indra/newview/llpanelland.cpp
@@ -58,14 +58,26 @@ public:
 
 bool    LLPanelLandInfo::postBuild()
 {
-    childSetAction("button buy land",boost::bind(onClickClaim));
-    childSetAction("button abandon land", boost::bind(onClickRelease));
-    childSetAction("button subdivide land", boost::bind(onClickDivide));
-    childSetAction("button join land", boost::bind(onClickJoin));
-    childSetAction("button about land", boost::bind(onClickAbout));
+    mButtonBuyLand = getChild<LLButton>("button buy land");
+    mButtonBuyLand->setCommitCallback(boost::bind(&LLPanelLandInfo::onClickClaim, this));
+
+    mButtonAbandonLand = getChild<LLButton>("button abandon land");
+    mButtonAbandonLand->setCommitCallback(boost::bind(&LLPanelLandInfo::onClickRelease, this));
+
+    mButtonSubdivLand = getChild<LLButton>("button subdivide land");
+    mButtonSubdivLand->setCommitCallback(boost::bind(&LLPanelLandInfo::onClickDivide, this));
+
+    mButtonJoinLand = getChild<LLButton>("button join land");
+    mButtonJoinLand->setCommitCallback(boost::bind(&LLPanelLandInfo::onClickJoin, this));
+
+    mButtonAboutLand = getChild<LLButton>("button about land");
+    mButtonAboutLand->setCommitCallback(boost::bind(&LLPanelLandInfo::onClickAbout, this));
 
     mCheckShowOwners = getChild<LLCheckBoxCtrl>("checkbox show owners");
-    getChild<LLUICtrl>("checkbox show owners")->setValue(gSavedSettings.getBOOL("ShowParcelOwners"));
+    mCheckShowOwners->setValue(gSavedSettings.getBOOL("ShowParcelOwners"));
+
+    mTextArea = getChild<LLTextBox>("label_area");
+    mTextAreaPrice = getChild<LLTextBox>("label_area_price");
 
     return true;
 }
@@ -119,17 +131,14 @@ void LLPanelLandInfo::refresh()
     if (!parcel || !regionp)
     {
         // nothing selected, disable panel
-        getChildView("label_area_price")->setVisible(false);
-        getChildView("label_area")->setVisible(false);
+        mTextAreaPrice->setVisible(false);
+        mTextArea->setVisible(false);
 
-        //mTextPrice->setText(LLStringUtil::null);
-        getChild<LLUICtrl>("textbox price")->setValue(LLStringUtil::null);
-
-        getChildView("button buy land")->setEnabled(false);
-        getChildView("button abandon land")->setEnabled(false);
-        getChildView("button subdivide land")->setEnabled(false);
-        getChildView("button join land")->setEnabled(false);
-        getChildView("button about land")->setEnabled(false);
+        mButtonBuyLand->setEnabled(false);
+        mButtonAbandonLand->setEnabled(false);
+        mButtonSubdivLand->setEnabled(false);
+        mButtonJoinLand->setEnabled(false);
+        mButtonAboutLand->setEnabled(false);
     }
     else
     {
@@ -147,11 +156,11 @@ void LLPanelLandInfo::refresh()
 
         if (is_public && !LLViewerParcelMgr::getInstance()->getParcelSelection()->getMultipleOwners())
         {
-            getChildView("button buy land")->setEnabled(true);
+            mButtonBuyLand->setEnabled(true);
         }
         else
         {
-            getChildView("button buy land")->setEnabled(can_buy);
+            mButtonBuyLand->setEnabled(can_buy);
         }
 
         bool owner_release = LLViewerParcelMgr::isParcelOwnedByAgent(parcel, GP_LAND_RELEASE);
@@ -163,16 +172,16 @@ void LLPanelLandInfo::refresh()
         bool manager_divideable = ( gAgent.canManageEstate()
                                 && ((parcel->getOwnerID() == regionp->getOwner()) || owner_divide) );
 
-        getChildView("button abandon land")->setEnabled(owner_release || manager_releaseable || gAgent.isGodlike());
+        mButtonAbandonLand->setEnabled(owner_release || manager_releaseable || gAgent.isGodlike());
 
         // only mainland sims are subdividable by owner
         if (regionp->getRegionFlag(REGION_FLAGS_ALLOW_PARCEL_CHANGES))
         {
-            getChildView("button subdivide land")->setEnabled(owner_divide || manager_divideable || gAgent.isGodlike());
+            mButtonSubdivLand->setEnabled(owner_divide || manager_divideable || gAgent.isGodlike());
         }
         else
         {
-            getChildView("button subdivide land")->setEnabled(manager_divideable || gAgent.isGodlike());
+            mButtonSubdivLand->setEnabled(manager_divideable || gAgent.isGodlike());
         }
 
         // To join land, must have something selected,
@@ -183,15 +192,15 @@ void LLPanelLandInfo::refresh()
             //&& LLViewerParcelMgr::getInstance()->getSelfCount() > 1
             && !LLViewerParcelMgr::getInstance()->getParcelSelection()->getWholeParcelSelected())
         {
-            getChildView("button join land")->setEnabled(true);
+            mButtonJoinLand->setEnabled(true);
         }
         else
         {
             LL_DEBUGS() << "Invalid selection for joining land" << LL_ENDL;
-            getChildView("button join land")->setEnabled(false);
+            mButtonJoinLand->setEnabled(false);
         }
 
-        getChildView("button about land")->setEnabled(true);
+        mButtonAboutLand->setEnabled(true);
 
         // show pricing information
         S32 area;
@@ -206,47 +215,42 @@ void LLPanelLandInfo::refresh()
                                    &dwell);
         if(is_public || (is_for_sale && LLViewerParcelMgr::getInstance()->getParcelSelection()->getWholeParcelSelected()))
         {
-            getChild<LLUICtrl>("label_area_price")->setTextArg("[PRICE]", llformat("%d",claim_price));
-            getChild<LLUICtrl>("label_area_price")->setTextArg("[AREA]", llformat("%d",area));
-            getChildView("label_area_price")->setVisible(true);
-            getChildView("label_area")->setVisible(false);
+            mTextAreaPrice->setTextArg("[PRICE]", llformat("%d",claim_price));
+            mTextAreaPrice->setTextArg("[AREA]", llformat("%d",area));
+            mTextAreaPrice->setVisible(true);
+            mTextArea->setVisible(false);
         }
         else
         {
-            getChildView("label_area_price")->setVisible(false);
-            getChild<LLUICtrl>("label_area")->setTextArg("[AREA]", llformat("%d",area));
-            getChildView("label_area")->setVisible(true);
+            mTextAreaPrice->setVisible(false);
+            mTextArea->setTextArg("[AREA]", llformat("%d",area));
+            mTextArea->setVisible(true);
         }
     }
 }
 
 
-//static
 void LLPanelLandInfo::onClickClaim()
 {
     LLViewerParcelMgr::getInstance()->startBuyLand();
 }
 
 
-//static
 void LLPanelLandInfo::onClickRelease()
 {
     LLViewerParcelMgr::getInstance()->startReleaseLand();
 }
 
-// static
 void LLPanelLandInfo::onClickDivide()
 {
     LLViewerParcelMgr::getInstance()->startDivideLand();
 }
 
-// static
 void LLPanelLandInfo::onClickJoin()
 {
     LLViewerParcelMgr::getInstance()->startJoinLand();
 }
 
-//static
 void LLPanelLandInfo::onClickAbout()
 {
     // Promote the rectangle selection to a parcel selection
diff --git a/indra/newview/llpanelland.h b/indra/newview/llpanelland.h
index 7d0c6936bd..aeadee4085 100644
--- a/indra/newview/llpanelland.h
+++ b/indra/newview/llpanelland.h
@@ -46,20 +46,27 @@ public:
     void refresh() override;
     static void refreshAll();
 
-    LLCheckBoxCtrl  *mCheckShowOwners;
-
 protected:
-    static void onClickClaim();
-    static void onClickRelease();
-    static void onClickDivide();
-    static void onClickJoin();
-    static void onClickAbout();
+    void onClickClaim();
+    void onClickRelease();
+    void onClickDivide();
+    void onClickJoin();
+    void onClickAbout();
 
 protected:
     bool postBuild() override;
 
     static LLPanelLandSelectObserver* sObserver;
     static LLPanelLandInfo* sInstance;
+private:
+    LLCheckBoxCtrl  *mCheckShowOwners = nullptr;
+    LLButton* mButtonBuyLand = nullptr;
+    LLButton* mButtonAbandonLand = nullptr;
+    LLButton* mButtonSubdivLand = nullptr;
+    LLButton* mButtonJoinLand = nullptr;
+    LLButton* mButtonAboutLand = nullptr;
+    LLTextBox* mTextArea = nullptr;
+    LLTextBox* mTextAreaPrice = nullptr;
 };
 
 #endif

From a067f935358098d57f472a5fb8d475e99dd5c510 Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Wed, 24 Jul 2024 19:34:35 -0400
Subject: [PATCH 26/30] Fix findChild calls during blocked list draw

---
 indra/newview/llpanelblockedlist.cpp | 18 ++++++++++++------
 indra/newview/llpanelblockedlist.h   |  7 ++++++-
 2 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/indra/newview/llpanelblockedlist.cpp b/indra/newview/llpanelblockedlist.cpp
index 0de22fce25..7d55ba3265 100644
--- a/indra/newview/llpanelblockedlist.cpp
+++ b/indra/newview/llpanelblockedlist.cpp
@@ -94,16 +94,21 @@ bool LLPanelBlockedList::postBuild()
         break;
     }
 
+    mBlockedGearBtn = getChild<LLMenuButton>("blocked_gear_btn");
+
     // Use the context menu of the Block list for the Block tab gear menu.
     LLToggleableMenu* blocked_gear_menu = mBlockedList->getContextMenu();
     if (blocked_gear_menu)
     {
-        getChild<LLMenuButton>("blocked_gear_btn")->setMenu(blocked_gear_menu, LLMenuButton::MP_BOTTOM_LEFT);
+        mBlockedGearBtn->setMenu(blocked_gear_menu, LLMenuButton::MP_BOTTOM_LEFT);
     }
+    mUnblockBtn = getChild<LLButton>("unblock_btn");
+    mUnblockBtn->setCommitCallback(boost::bind(&LLPanelBlockedList::unblockItem, this));
 
-    getChild<LLButton>("unblock_btn")->setCommitCallback(boost::bind(&LLPanelBlockedList::unblockItem, this));
     getChild<LLFilterEditor>("blocked_filter_input")->setCommitCallback(boost::bind(&LLPanelBlockedList::onFilterEdit, this, _2));
 
+    mBlockLimitText = getChild<LLUICtrl>("block_limit");
+
     return LLPanel::postBuild();
 }
 
@@ -140,11 +145,12 @@ void LLPanelBlockedList::showPanelAndSelect(const LLUUID& idToSelect)
 void LLPanelBlockedList::updateButtons()
 {
     bool hasSelected = NULL != mBlockedList->getSelectedItem();
-    getChildView("unblock_btn")->setEnabled(hasSelected);
-    getChildView("blocked_gear_btn")->setEnabled(hasSelected);
+    mUnblockBtn->setEnabled(hasSelected);
+    mBlockedGearBtn->setEnabled(hasSelected);
 
-    getChild<LLUICtrl>("block_limit")->setTextArg("[COUNT]", llformat("%d", mBlockedList->getMuteListSize()));
-    getChild<LLUICtrl>("block_limit")->setTextArg("[LIMIT]", llformat("%d", gSavedSettings.getS32("MuteListLimit")));
+    static LLCachedControl<S32> mute_list_limit(gSavedSettings, "MuteListLimit");
+    mBlockLimitText->setTextArg("[COUNT]", llformat("%d", mBlockedList->getMuteListSize()));
+    mBlockLimitText->setTextArg("[LIMIT]", llformat("%d", mute_list_limit()));
 }
 
 void LLPanelBlockedList::unblockItem()
diff --git a/indra/newview/llpanelblockedlist.h b/indra/newview/llpanelblockedlist.h
index 446f3d4bad..1f470199ce 100644
--- a/indra/newview/llpanelblockedlist.h
+++ b/indra/newview/llpanelblockedlist.h
@@ -33,6 +33,8 @@
 
 class LLAvatarName;
 class LLBlockList;
+class LLMenuButton;
+class LLButton;
 
 class LLPanelBlockedList : public LLPanel
 {
@@ -78,7 +80,10 @@ private:
     static void callbackBlockByName(const std::string& text);
 
 private:
-    LLBlockList* mBlockedList;
+    LLBlockList* mBlockedList = nullptr;
+    LLUICtrl*    mBlockLimitText = nullptr;
+    LLMenuButton* mBlockedGearBtn = nullptr;
+    LLButton*    mUnblockBtn = nullptr;
     LLHandle<LLFloater> mPicker;
 };
 

From 66d2c846b180d58e4e90052d87e27505e2d22736 Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Wed, 24 Jul 2024 22:27:10 -0400
Subject: [PATCH 27/30] Fix further recursive findChild stalls from environment
 panel

---
 indra/newview/llpanelenvironment.cpp | 38 +++++++++++++++-------------
 indra/newview/llpanelenvironment.h   |  8 ++++--
 2 files changed, 27 insertions(+), 19 deletions(-)

diff --git a/indra/newview/llpanelenvironment.cpp b/indra/newview/llpanelenvironment.cpp
index 0c8bbbf308..51e2c05070 100644
--- a/indra/newview/llpanelenvironment.cpp
+++ b/indra/newview/llpanelenvironment.cpp
@@ -214,7 +214,10 @@ bool LLPanelEnvironmentInfo::postBuild()
 
     for (U32 idx = 0; idx < ALTITUDE_PREFIXERS_COUNT; idx++)
     {
-        mAltitudePrefixers[idx] = findChild<LLSettingsDropTarget>("sdt_" + alt_prefixes[idx]);
+        mAltitudeDropTarget[idx] = findChild<LLSettingsDropTarget>("sdt_" + alt_prefixes[idx]);
+        mAltitudeLabels[idx] = findChild<LLTextBox>("txt_" + alt_prefixes[idx]);
+        mAltitudeEditor[idx] = findChild<LLLineEditor>("edt_invname_" + alt_prefixes[idx]);
+        mAltitudePanels[idx] = findChild<LLView>("pnl_" + alt_prefixes[idx]);
     }
 
     for (U32 idx = 0; idx < ALTITUDE_SLIDER_COUNT; idx++)
@@ -224,11 +227,12 @@ bool LLPanelEnvironmentInfo::postBuild()
         {
             drop_target->setPanel(this, alt_sliders[idx]);
         }
+
         // set initial values to prevent [ALTITUDE] from displaying
-        updateAltLabel(alt_prefixes[idx], idx + 2, (F32)(idx * 1000));
+        updateAltLabel(idx, idx + 2, (F32)(idx * 1000));
     }
-    getChild<LLSettingsDropTarget>("sdt_" + alt_prefixes[3])->setPanel(this, alt_prefixes[3]);
-    getChild<LLSettingsDropTarget>("sdt_" + alt_prefixes[4])->setPanel(this, alt_prefixes[4]);
+    mAltitudeDropTarget[3]->setPanel(this, alt_prefixes[3]);
+    mAltitudeDropTarget[4]->setPanel(this, alt_prefixes[4]);
 
     return true;
 }
@@ -344,7 +348,7 @@ void LLPanelEnvironmentInfo::refresh()
                 // Something is very very wrong
                 LL_WARNS_ONCE("ENVPANEL") << "Failed to set up altitudes for parcel id " << getParcelId() << LL_ENDL;
             }
-            updateAltLabel(alt_prefixes[idx], idx + 2, altitude);
+            updateAltLabel(idx, idx + 2, altitude);
             mAltitudes[alt_sliders[idx]] = AltitudeData(idx + 2, idx, altitude);
         }
         if (mMultiSliderAltitudes->getCurNumSliders() != ALTITUDE_SLIDER_COUNT)
@@ -355,8 +359,8 @@ void LLPanelEnvironmentInfo::refresh()
         mMultiSliderAltitudes->resetCurSlider();
     }
 
-    updateAltLabel(alt_prefixes[3], 1, 0); // ground
-    updateAltLabel(alt_prefixes[4], 0, 0); // water
+    updateAltLabel(3, 1, 0); // ground
+    updateAltLabel(4, 0, 0); // water
 
 }
 
@@ -552,9 +556,9 @@ bool LLPanelEnvironmentInfo::setControlsEnabled(bool enabled)
 
     for (U32 idx = 0; idx < ALTITUDE_PREFIXERS_COUNT; idx++)
     {
-        if (mAltitudePrefixers[idx])
+        if (mAltitudeDropTarget[idx])
         {
-            mAltitudePrefixers[idx]->setDndEnabled(can_enable);
+            mAltitudeDropTarget[idx]->setDndEnabled(can_enable);
         }
     }
 
@@ -571,7 +575,7 @@ void LLPanelEnvironmentInfo::clearDirtyFlag(U32 flag)
     mDirtyFlag &= ~flag;
 }
 
-void LLPanelEnvironmentInfo::updateAltLabel(const std::string &alt_prefix, U32 sky_index, F32 alt_value)
+void LLPanelEnvironmentInfo::updateAltLabel(U32 alt_index, U32 sky_index, F32 alt_value)
 {
     LLRect sld_rect = mMultiSliderAltitudes->getRect();
     S32 sld_range = sld_rect.getHeight();
@@ -580,9 +584,9 @@ void LLPanelEnvironmentInfo::updateAltLabel(const std::string &alt_prefix, U32 s
     S32 pos = (S32)((sld_range - sld_offset) * ((alt_value - 100) / (4000 - 100)));
 
     // get related views
-    LLTextBox* text = findChild<LLTextBox>("txt_" + alt_prefix);
-    LLLineEditor *field = findChild<LLLineEditor>("edt_invname_" + alt_prefix);
-    LLView *alt_panel = findChild<LLView>("pnl_" + alt_prefix);
+    LLTextBox* text = mAltitudeLabels[alt_index];
+    LLLineEditor* field = mAltitudeEditor[alt_index];
+    LLView* alt_panel = mAltitudePanels[alt_index];
 
     if (text && (sky_index > 1))
     {
@@ -628,7 +632,7 @@ void LLPanelEnvironmentInfo::readjustAltLabels()
     // Find the middle one
     for (U32 i = 0; i < ALTITUDE_SLIDER_COUNT; i++)
     {
-        LLView* cmp_view = findChild<LLView>(alt_panels[i], true);
+        LLView* cmp_view = mAltitudePanels[i];
         if (!cmp_view) return;
         LLRect cmp_rect = cmp_view->getRect();
         S32 pos = 0;
@@ -639,7 +643,7 @@ void LLPanelEnvironmentInfo::readjustAltLabels()
         {
             if (i != j)
             {
-                LLView* intr_view = findChild<LLView>(alt_panels[j], true);
+                LLView* intr_view = mAltitudePanels[j];
                 if (!intr_view) return;
                 LLRect intr_rect = intr_view->getRect();
                 if (cmp_rect.mBottom >= intr_rect.mBottom)
@@ -687,7 +691,7 @@ void LLPanelEnvironmentInfo::readjustAltLabels()
     {
         if (i != midle_ind)
         {
-            LLView* trn_view = findChild<LLView>(alt_panels[i], true);
+            LLView* trn_view = mAltitudePanels[i];
             LLRect trn_rect = trn_view->getRect();
 
             if (trn_rect.mBottom <= midle_rect.mTop && trn_rect.mBottom >= midle_rect.mBottom)
@@ -807,7 +811,7 @@ void LLPanelEnvironmentInfo::onAltSliderCallback(LLUICtrl *cntrl, const LLSD &da
         }
         iter->second.mTrackIndex = new_index;
 
-        updateAltLabel(alt_prefixes[iter->second.mLabelIndex], iter->second.mTrackIndex, iter->second.mAltitude);
+        updateAltLabel(iter->second.mLabelIndex, iter->second.mTrackIndex, iter->second.mAltitude);
         iter++;
     }
 
diff --git a/indra/newview/llpanelenvironment.h b/indra/newview/llpanelenvironment.h
index 0544524ece..8942e20119 100644
--- a/indra/newview/llpanelenvironment.h
+++ b/indra/newview/llpanelenvironment.h
@@ -113,7 +113,7 @@ protected:
     bool                        getIsDirty() const                  { return (mDirtyFlag != 0); }
     bool                        getIsDirtyFlag(U32 flag) const      { return ((mDirtyFlag & flag) != 0); }
     U32                         getDirtyFlag() const                { return mDirtyFlag; }
-    void                        updateAltLabel(const std::string &alt_prefix, U32 sky_index, F32 alt_value);
+    void                        updateAltLabel(U32 alt_index, U32 sky_index, F32 alt_value);
     void                        readjustAltLabels();
 
     void                        onSldDayLengthChanged(F32 value);
@@ -198,7 +198,11 @@ protected:
     LLIconCtrl* mIconWater = nullptr;
 
     std::array<LLUICtrl*, ALTITUDE_MARKERS_COUNT> mAltitudeMarkers;
-    std::array<LLSettingsDropTarget*, ALTITUDE_PREFIXERS_COUNT> mAltitudePrefixers;
+    std::array<LLSettingsDropTarget*, ALTITUDE_PREFIXERS_COUNT> mAltitudeDropTarget;
+
+    std::array<LLTextBox*, ALTITUDE_PREFIXERS_COUNT> mAltitudeLabels;
+    std::array<LLLineEditor*, ALTITUDE_PREFIXERS_COUNT> mAltitudeEditor;
+    std::array<LLView*, ALTITUDE_PREFIXERS_COUNT> mAltitudePanels;
 
 protected:
     typedef boost::signals2::connection connection_t;

From 6b20d98aaac093e043c6e23fbcf6d4e1f62d13ba Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Wed, 24 Jul 2024 23:12:44 -0400
Subject: [PATCH 28/30] Fix one more group findChild stall

---
 indra/newview/llpanelgroup.cpp | 16 ++++++++--------
 indra/newview/llpanelgroup.h   |  1 +
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/indra/newview/llpanelgroup.cpp b/indra/newview/llpanelgroup.cpp
index 598df0135e..3db0f90df8 100644
--- a/indra/newview/llpanelgroup.cpp
+++ b/indra/newview/llpanelgroup.cpp
@@ -169,6 +169,8 @@ bool LLPanelGroup::postBuild()
 
     mButtonCancel = getChild<LLButton>("btn_cancel");
 
+    mGroupNameCtrl = getChild<LLUICtrl>("group_name");
+
     childSetCommitCallback("back",boost::bind(&LLPanelGroup::onBackBtnClick,this),NULL);
 
     LLPanelGroupTab* panel_general = findChild<LLPanelGroupTab>("group_general_tab_panel");
@@ -311,9 +313,8 @@ void LLPanelGroup::update(LLGroupChange gc)
     if(gdatap)
     {
         std::string group_name =  gdatap->mName.empty() ? LLTrans::getString("LoadingData") : gdatap->mName;
-        LLUICtrl* group_name_ctrl = getChild<LLUICtrl>("group_name");
-        group_name_ctrl->setValue(group_name);
-        group_name_ctrl->setToolTip(group_name);
+        mGroupNameCtrl->setValue(group_name);
+        mGroupNameCtrl->setToolTip(group_name);
 
         LLGroupData agent_gdatap;
         bool is_member = gAgent.getGroupData(mID,agent_gdatap) || gAgent.isGodlikeWithoutAdminMenuFakery();
@@ -365,9 +366,8 @@ void LLPanelGroup::setGroupID(const LLUUID& group_id)
     if(gdatap)
     {
         std::string group_name =  gdatap->mName.empty() ? LLTrans::getString("LoadingData") : gdatap->mName;
-        LLUICtrl* group_name_ctrl = getChild<LLUICtrl>("group_name");
-        group_name_ctrl->setValue(group_name);
-        group_name_ctrl->setToolTip(group_name);
+        mGroupNameCtrl->setValue(group_name);
+        mGroupNameCtrl->setToolTip(group_name);
     }
 
     bool is_null_group_id = group_id == LLUUID::null;
@@ -417,7 +417,7 @@ void LLPanelGroup::setGroupID(const LLUUID& group_id)
         tab_land->setVisible(false);
         tab_experiences->setVisible(false);
 
-        getChild<LLUICtrl>("group_name")->setVisible(false);
+        mGroupNameCtrl->setVisible(false);
         getChild<LLUICtrl>("group_name_editor")->setVisible(true);
 
         if(mButtonCall)
@@ -449,7 +449,7 @@ void LLPanelGroup::setGroupID(const LLUUID& group_id)
         tab_land->setVisible(is_member);
         tab_experiences->setVisible(is_member);
 
-        getChild<LLUICtrl>("group_name")->setVisible(true);
+        mGroupNameCtrl->setVisible(true);
         getChild<LLUICtrl>("group_name_editor")->setVisible(false);
 
         if(mButtonApply)
diff --git a/indra/newview/llpanelgroup.h b/indra/newview/llpanelgroup.h
index 1dbc8c32ff..d7dec94c60 100644
--- a/indra/newview/llpanelgroup.h
+++ b/indra/newview/llpanelgroup.h
@@ -117,6 +117,7 @@ protected:
 
     LLAccordionCtrl* mGroupsAccordion = nullptr;
 
+    LLUICtrl*       mGroupNameCtrl = nullptr;
     LLButton*       mButtonJoin = nullptr;
     LLButton*       mButtonApply = nullptr;
     LLButton*       mButtonCall = nullptr;

From 7bb62fff08942db95805de454b43d006ca47428b Mon Sep 17 00:00:00 2001
From: Rye Mutt <rye@alchemyviewer.org>
Date: Thu, 25 Jul 2024 08:44:38 -0400
Subject: [PATCH 29/30] Fix precommit whitespace failure

---
 indra/newview/llviewermenu.cpp | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/indra/newview/llviewermenu.cpp b/indra/newview/llviewermenu.cpp
index 888b607bfb..cd0b3dbd0c 100644
--- a/indra/newview/llviewermenu.cpp
+++ b/indra/newview/llviewermenu.cpp
@@ -377,17 +377,17 @@ void LLMenuParcelObserver::changed()
     LLParcel *parcel = LLViewerParcelMgr::getInstance()->getParcelSelection()->getParcel();
     if (gMenuLand && parcel)
     {
-	    if (!mLandBuyPassHandle.isDead())
-	    {
-	        LLParcel *parcel = LLViewerParcelMgr::getInstance()->getParcelSelection()->getParcel();
-	        static_cast<LLMenuItemCallGL*>(mLandBuyPassHandle.get())->setEnabled(LLPanelLandGeneral::enableBuyPass(NULL) && !(parcel->getOwnerID() == gAgent.getID()));
-	    }
+        if (!mLandBuyPassHandle.isDead())
+        {
+            LLParcel *parcel = LLViewerParcelMgr::getInstance()->getParcelSelection()->getParcel();
+            static_cast<LLMenuItemCallGL*>(mLandBuyPassHandle.get())->setEnabled(LLPanelLandGeneral::enableBuyPass(NULL) && !(parcel->getOwnerID() == gAgent.getID()));
+        }
 
-	    if (!mLandBuyHandle.isDead())
-	    {
-	        bool buyable = enable_buy_land(NULL);
-	        static_cast<LLMenuItemCallGL*>(mLandBuyHandle.get())->setEnabled(buyable);
-	    }
+        if (!mLandBuyHandle.isDead())
+        {
+            bool buyable = enable_buy_land(NULL);
+            static_cast<LLMenuItemCallGL*>(mLandBuyHandle.get())->setEnabled(buyable);
+        }
     }
 }
 

From 4d7f622a3c6a2fdec1c57ad4506ae49786b37dfc Mon Sep 17 00:00:00 2001
From: Andrey Kleshchev <117672381+akleshchev@users.noreply.github.com>
Date: Thu, 25 Jul 2024 16:02:03 +0300
Subject: [PATCH 30/30] viewer#2065 Region restart schedule floater

---
 indra/newview/CMakeLists.txt                  |   2 +
 indra/newview/app_settings/settings.xml       |  11 +
 indra/newview/llfloaterregioninfo.cpp         |  23 ++
 indra/newview/llfloaterregioninfo.h           |   2 +
 .../llfloaterregionrestartschedule.cpp        | 386 ++++++++++++++++++
 .../newview/llfloaterregionrestartschedule.h  |  74 ++++
 indra/newview/llviewerregion.cpp              |   1 +
 .../en/floater_region_restart_schedule.xml    | 278 +++++++++++++
 .../default/xui/en/panel_region_general.xml   |  14 +-
 9 files changed, 790 insertions(+), 1 deletion(-)
 create mode 100644 indra/newview/llfloaterregionrestartschedule.cpp
 create mode 100644 indra/newview/llfloaterregionrestartschedule.h
 create mode 100644 indra/newview/skins/default/xui/en/floater_region_restart_schedule.xml

diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt
index d4c2875c6c..def2d8f0c0 100644
--- a/indra/newview/CMakeLists.txt
+++ b/indra/newview/CMakeLists.txt
@@ -278,6 +278,7 @@ set(viewer_SOURCE_FILES
     llfloaterregioninfo.cpp
     llfloaterreporter.cpp
     llfloaterregionrestarting.cpp
+    llfloaterregionrestartschedule.cpp
     llfloatersavecamerapreset.cpp
     llfloatersaveprefpreset.cpp
     llfloatersceneloadstats.cpp
@@ -945,6 +946,7 @@ set(viewer_HEADER_FILES
     llfloaterregioninfo.h
     llfloaterreporter.h
     llfloaterregionrestarting.h
+    llfloaterregionrestartschedule.h
     llfloatersavecamerapreset.h
     llfloatersaveprefpreset.h
     llfloatersceneloadstats.h
diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml
index 235d294849..97cab58eb1 100644
--- a/indra/newview/app_settings/settings.xml
+++ b/indra/newview/app_settings/settings.xml
@@ -12682,6 +12682,17 @@
       <key>Value</key>
       <integer>1</integer>
     </map>
+    <key>Use24HourClock</key>
+    <map>
+        <key>Comment</key>
+        <string>12 vs 24. At the moment only for region restart schedule floater</string>
+        <key>Persist</key>
+        <integer>0</integer>
+        <key>Type</key>
+        <string>Boolean</string>
+        <key>Value</key>
+        <integer>0</integer>
+    </map>
     <key>EnvironmentPersistAcrossLogin</key>
     <map>
       <key>Comment</key>
diff --git a/indra/newview/llfloaterregioninfo.cpp b/indra/newview/llfloaterregioninfo.cpp
index cc9aca1338..02ef342c2a 100644
--- a/indra/newview/llfloaterregioninfo.cpp
+++ b/indra/newview/llfloaterregioninfo.cpp
@@ -61,6 +61,7 @@
 #include "llfloatergroups.h"
 #include "llfloaterreg.h"
 #include "llfloaterregiondebugconsole.h"
+#include "llfloaterregionrestartschedule.h"
 #include "llfloatertelehub.h"
 #include "llgltfmateriallist.h"
 #include "llinventorymodel.h"
@@ -259,6 +260,7 @@ bool LLFloaterRegionInfo::postBuild()
     panel = new LLPanelRegionGeneralInfo;
     mInfoPanels.push_back(panel);
     panel->getCommitCallbackRegistrar().add("RegionInfo.ManageTelehub", boost::bind(&LLPanelRegionInfo::onClickManageTelehub, panel));
+    panel->getCommitCallbackRegistrar().add("RegionInfo.ManageRestart", boost::bind(&LLPanelRegionInfo::onClickManageRestartSchedule, panel));
     panel->buildFromFile("panel_region_general.xml");
     mTab->addTabPanel(panel);
 
@@ -862,6 +864,25 @@ void LLPanelRegionInfo::onClickManageTelehub()
     LLFloaterReg::showInstance("telehubs");
 }
 
+void LLPanelRegionInfo::onClickManageRestartSchedule()
+{
+    LLFloater* floaterp = mFloaterRestartScheduleHandle.get();
+    // Show the dialog
+    if (!floaterp)
+    {
+        floaterp = new LLFloaterRegionRestartSchedule(this);
+    }
+
+    if (floaterp->getVisible())
+    {
+        floaterp->closeFloater();
+    }
+    else
+    {
+        floaterp->openFloater();
+    }
+}
+
 /////////////////////////////////////////////////////////////////////////////
 // LLPanelRegionGeneralInfo
 //
@@ -877,6 +898,8 @@ bool LLPanelRegionGeneralInfo::refreshFromRegion(LLViewerRegion* region)
     getChildView("kick_all_btn")->setEnabled(allow_modify);
     getChildView("im_btn")->setEnabled(allow_modify);
     getChildView("manage_telehub_btn")->setEnabled(allow_modify);
+    getChildView("manage_restart_btn")->setEnabled(allow_modify);
+    getChildView("manage_restart_btn")->setVisible(LLFloaterRegionRestartSchedule::canUse());
 
     // Data gets filled in by processRegionInfo
 
diff --git a/indra/newview/llfloaterregioninfo.h b/indra/newview/llfloaterregioninfo.h
index 60564435d7..b604a28fc3 100644
--- a/indra/newview/llfloaterregioninfo.h
+++ b/indra/newview/llfloaterregioninfo.h
@@ -154,6 +154,7 @@ public:
     void disableButton(const std::string& btn_name);
 
     void onClickManageTelehub();
+    void onClickManageRestartSchedule();
 
 protected:
     void initCtrl(const std::string& name);
@@ -174,6 +175,7 @@ protected:
 
     // member data
     LLHost mHost;
+    LLHandle<LLFloater> mFloaterRestartScheduleHandle;
 };
 
 /////////////////////////////////////////////////////////////////////////////
diff --git a/indra/newview/llfloaterregionrestartschedule.cpp b/indra/newview/llfloaterregionrestartschedule.cpp
new file mode 100644
index 0000000000..59bcb22dce
--- /dev/null
+++ b/indra/newview/llfloaterregionrestartschedule.cpp
@@ -0,0 +1,386 @@
+/**
+ * @file llfloaterregionrestartschedule.cpp
+ * @author Andrii Kleshchev
+ * @brief LLFloaterRegionRestartSchedule class
+ *
+ * $LicenseInfo:firstyear=2024&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2024, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "llfloaterregionrestartschedule.h"
+
+#include "llagent.h"
+#include "llbutton.h"
+#include "llcheckboxctrl.h"
+#include "lllineeditor.h"
+#include "llviewercontrol.h"
+
+
+// match with values used by capability
+constexpr char CHECKBOX_PREFIXES[] =
+{
+    's',
+    'm',
+    't',
+    'w',
+    'r',
+    'f',
+    'a',
+};
+
+const std::string CHECKBOX_NAME = "_chk";
+
+LLFloaterRegionRestartSchedule::LLFloaterRegionRestartSchedule(
+    LLView* owner)
+    : LLFloater(LLSD())
+    , mOwnerHandle(owner->getHandle())
+{
+    buildFromFile("floater_region_restart_schedule.xml");
+}
+
+LLFloaterRegionRestartSchedule::~LLFloaterRegionRestartSchedule()
+{
+
+}
+
+bool LLFloaterRegionRestartSchedule::postBuild()
+{
+    mPMAMButton = getChild<LLButton>("am_pm_btn");
+    mPMAMButton->setClickedCallback([this](LLUICtrl*, const LLSD&) { onPMAMButtonClicked(); });
+
+    // By default mPMAMButton is supposed to be visible.
+    // If localized xml set mPMAMButton to be invisible, assume
+    // 24h format and prealligned "UTC" label
+    if (mPMAMButton->getVisible())
+    {
+        bool use_24h_format = gSavedSettings.getBOOL("Use24HourClock");
+        if (use_24h_format)
+        {
+            mPMAMButton->setVisible(false);
+            LLUICtrl* lbl = getChild<LLUICtrl>("utc_label");
+            lbl->translate(-mPMAMButton->getRect().getWidth(), 0);
+        }
+    }
+
+    mSaveButton = getChild<LLButton>("save_btn");
+    mSaveButton->setClickedCallback([this](LLUICtrl*, const LLSD&) { onSaveButtonClicked(); });
+
+    mCancelButton = getChild<LLButton>("cancel_btn");
+    mCancelButton->setClickedCallback([this](LLUICtrl*, const LLSD&) { closeFloater(false); });
+
+
+    mHoursLineEditor = getChild<LLLineEditor>("hours_edt");
+    mHoursLineEditor->setPrevalidate(LLTextValidate::validateNonNegativeS32);
+    mHoursLineEditor->setCommitCallback([this](LLUICtrl* ctrl, const LLSD& value) { onCommitHours(value); });
+
+    mMinutesLineEditor = getChild<LLLineEditor>("minutes_edt");
+    mMinutesLineEditor->setPrevalidate(LLTextValidate::validateNonNegativeS32);
+    mMinutesLineEditor->setCommitCallback([this](LLUICtrl* ctrl, const LLSD& value) { onCommitMinutes(value); });
+
+    for (char c : CHECKBOX_PREFIXES)
+    {
+        std::string name = c + CHECKBOX_NAME;
+        LLCheckBoxCtrl* chk = getChild<LLCheckBoxCtrl>(name);
+        chk->setCommitCallback([this](LLUICtrl* ctrl, const LLSD& value) { mSaveButton->setEnabled(true); });
+    }
+
+    resetUI(false);
+
+    return true;
+}
+
+void LLFloaterRegionRestartSchedule::onOpen(const LLSD& key)
+{
+    std::string url = gAgent.getRegionCapability("RegionSchedule");
+    if (!url.empty())
+    {
+        LLCoros::instance().launch("LLFloaterRegionRestartSchedule::requestRegionShcheduleCoro",
+            boost::bind(&LLFloaterRegionRestartSchedule::requestRegionShcheduleCoro, url, getHandle()));
+
+        mSaveButton->setEnabled(false);
+    }
+    else
+    {
+        LL_WARNS("Region") << "Started region schedule floater, but RegionSchedule capability is not available" << LL_ENDL;
+    }
+}
+
+void LLFloaterRegionRestartSchedule::draw()
+{
+    LLView* owner = mOwnerHandle.get();
+    if (owner)
+    {
+        static LLCachedControl<F32> max_opacity(gSavedSettings, "PickerContextOpacity", 0.4f);
+        drawConeToOwner(mContextConeOpacity, max_opacity, owner);
+    }
+
+    LLFloater::draw();
+}
+
+void LLFloaterRegionRestartSchedule::onPMAMButtonClicked()
+{
+    mSaveButton->setEnabled(true);
+    mTimeAM = !mTimeAM;
+    updateAMPM();
+}
+
+void LLFloaterRegionRestartSchedule::onSaveButtonClicked()
+{
+    std::string url = gAgent.getRegionCapability("RegionSchedule");
+    if (!url.empty())
+    {
+        std::string days;
+        for (char c : CHECKBOX_PREFIXES)
+        {
+            std::string name = c + CHECKBOX_NAME;
+            LLCheckBoxCtrl* chk = getChild<LLCheckBoxCtrl>(name);
+            if (chk->getValue())
+            {
+                days += c;
+            }
+        }
+        LLSD restart;
+        if (days.size() < 7)
+        {
+            LLStringUtil::toUpper(days);
+            restart["type"] = "W";
+            // if days are empty, will reset schedule
+            restart["days"] = days;
+        }
+        else
+        {
+            restart["type"] = "D";
+        }
+        S32 hours = mHoursLineEditor->getValue().asInteger();
+        if (mPMAMButton->getVisible())
+        {
+            if (hours == 12)
+            {
+                hours = 0; // 12:00 AM equals 0:00, while 12:00 PM equals 12:00
+            }
+            if (!mTimeAM)
+            {
+                hours += 12;
+            }
+        }
+        restart["time"] = hours * 3600 + mMinutesLineEditor->getValue().asInteger() * 60;
+
+        LLSD body;
+        body["restart"] = restart; // event name, at the moment only "restart" is supported
+        LLCoros::instance().launch("LLFloaterRegionRestartSchedule::setRegionShcheduleCoro",
+            boost::bind(&LLFloaterRegionRestartSchedule::setRegionShcheduleCoro, url, body, getHandle()));
+
+        mSaveButton->setEnabled(false);
+    }
+    else
+    {
+        LL_WARNS("Region") << "Saving region schedule, but RegionSchedule capability is not available" << LL_ENDL;
+    }
+}
+
+void LLFloaterRegionRestartSchedule::onCommitHours(const LLSD& value)
+{
+    S32 hours = value.asInteger();
+    if (mPMAMButton->getVisible())
+    {
+        // 0:00 equals 12:00 AM 1:00 equals 1:00 AM, 12am < 1am < 2am < 3am...
+        if (hours == 0) hours = 12;
+        llclamp(hours, 1, 12);
+    }
+    else
+    {
+        llclamp(hours, 0, 23);
+    }
+    mHoursLineEditor->setText(llformat("%02d", hours));
+    mSaveButton->setEnabled(true);
+}
+
+void LLFloaterRegionRestartSchedule::onCommitMinutes(const LLSD& value)
+{
+    S32 minutes = value.asInteger();
+    llclamp(minutes, 0, 59);
+    mMinutesLineEditor->setText(llformat("%02d", minutes));
+    mSaveButton->setEnabled(true);
+}
+
+void LLFloaterRegionRestartSchedule::resetUI(bool enable_ui)
+{
+    for (char c : CHECKBOX_PREFIXES)
+    {
+        std::string name = c + CHECKBOX_NAME;
+        LLCheckBoxCtrl* chk = getChild<LLCheckBoxCtrl>(name);
+        chk->setValue(false);
+        chk->setEnabled(enable_ui);
+    }
+    if (mPMAMButton->getVisible())
+    {
+        mHoursLineEditor->setValue("12");
+        mPMAMButton->setEnabled(enable_ui);
+    }
+    else
+    {
+        mHoursLineEditor->setValue("00");
+    }
+    mMinutesLineEditor->setValue("00");
+    mMinutesLineEditor->setEnabled(enable_ui);
+    mHoursLineEditor->setEnabled(enable_ui);
+    mTimeAM = true;
+    updateAMPM();
+}
+
+void LLFloaterRegionRestartSchedule::updateAMPM()
+{
+    std::string value;
+    if (mTimeAM)
+    {
+        value = getString("am_string");
+    }
+    else
+    {
+        value = getString("pm_string");
+    }
+    mPMAMButton->setLabel(value);
+}
+
+bool LLFloaterRegionRestartSchedule::canUse()
+{
+    std::string url = gAgent.getRegionCapability("RegionSchedule");
+    return !url.empty();
+}
+
+void LLFloaterRegionRestartSchedule::requestRegionShcheduleCoro(std::string url, LLHandle<LLFloater> handle)
+{
+    LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
+    LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
+        httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("RegionShcheduleRequest", httpPolicy));
+    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
+
+    httpOpts->setWantHeaders(true);
+
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url, httpOpts);
+
+    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
+    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
+
+    LLFloaterRegionRestartSchedule* floater = dynamic_cast<LLFloaterRegionRestartSchedule*>(handle.get());
+    if (!floater)
+    {
+        LL_DEBUGS("Region") << "Region Restart Schedule floater is already dead" << LL_ENDL;
+    }
+    else if (!status)
+    {
+        LL_WARNS("Region") << "Failed to get region schedule: " << status.toString() << LL_ENDL;
+        floater->resetUI(false);
+    }
+    else if (!result.has("restart"))
+    {
+        floater->resetUI(true); // no restart schedule yet
+    }
+    else
+    {
+        // example: 'restart':{'days':'TR','time':i7200,'type':'W'}
+        LLSD &restart = result["restart"];
+        std::string type = restart["type"];
+        std::string days = restart["days"];
+        if (type == "W") // weekly || restart.has("days")
+        {
+            LLStringUtil::toLower(days);
+            for (char c : CHECKBOX_PREFIXES)
+            {
+                bool enabled = days.find(c) != std::string::npos;
+                std::string name = c + CHECKBOX_NAME;
+                LLCheckBoxCtrl *chk = floater->getChild<LLCheckBoxCtrl>(name);
+                chk->setValue(enabled);
+                chk->setEnabled(true);
+            }
+        }
+        else // dayly
+        {
+            for (char c : CHECKBOX_PREFIXES)
+            {
+                std::string name = c + CHECKBOX_NAME;
+                LLCheckBoxCtrl* chk = floater->getChild<LLCheckBoxCtrl>(name);
+                chk->setValue(true);
+                chk->setEnabled(true);
+            }
+        }
+
+        S32 seconds_after_midnight = restart["time"].asInteger();
+        S32 hours = seconds_after_midnight / 3600;
+        S32 minutes = (seconds_after_midnight % 3600) / 60;
+
+        if (floater->mPMAMButton->getVisible())
+        {
+            if (hours >= 12)
+            {
+                hours -= 12;
+                floater->mTimeAM = false;
+            }
+            else
+            {
+                floater->mTimeAM = true;
+            }
+            if (hours == 0)
+            {
+                hours = 12; // 0:00 equals 12:00 AM , 1:00 equals 1:00 AM
+            }
+            floater->mPMAMButton->setEnabled(true);
+        }
+        else
+        {
+            floater->mTimeAM = true;
+        }
+        floater->updateAMPM();
+        floater->mHoursLineEditor->setText(llformat("%02d", hours));
+        floater->mHoursLineEditor->setEnabled(true);
+        floater->mMinutesLineEditor->setText(llformat("%02d", minutes));
+        floater->mMinutesLineEditor->setEnabled(true);
+
+        LL_DEBUGS("Region") << "Region restart schedule type: " << type
+            << " Days: " << days
+            << " Time:" << hours << ":" << minutes << LL_ENDL;
+    }
+}
+
+void LLFloaterRegionRestartSchedule::setRegionShcheduleCoro(std::string url, LLSD body, LLHandle<LLFloater> handle)
+{
+    LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
+    LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
+        httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("RegionShcheduleSetter", httpPolicy));
+    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
+
+    httpOpts->setWantHeaders(true);
+
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, body, httpOpts);
+
+    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
+    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
+
+    LLFloaterRegionRestartSchedule* floater = dynamic_cast<LLFloaterRegionRestartSchedule*>(handle.get());
+    if (floater)
+    {
+        floater->closeFloater();
+    }
+}
diff --git a/indra/newview/llfloaterregionrestartschedule.h b/indra/newview/llfloaterregionrestartschedule.h
new file mode 100644
index 0000000000..465ed538a5
--- /dev/null
+++ b/indra/newview/llfloaterregionrestartschedule.h
@@ -0,0 +1,74 @@
+/**
+ * @file llfloaterregionrestartschedule.h
+ * @author Andrii Kleshchev
+ * @brief LLFloaterRegionRestartSchedule class header file
+ *
+ * $LicenseInfo:firstyear=2024&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2024, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLFLOATERREGIONRESTARTSCHEDULE_H
+#define LL_LLFLOATERREGIONRESTARTSCHEDULE_H
+
+#include "llfloater.h"
+
+class LLLineEditor;
+class LLButton;
+
+class LLFloaterRegionRestartSchedule : public LLFloater
+{
+public:
+    LLFloaterRegionRestartSchedule(LLView* owner);
+
+    virtual ~LLFloaterRegionRestartSchedule();
+
+    bool postBuild() override;
+    void onOpen(const LLSD& key) override;
+    void draw() override;
+
+    void onPMAMButtonClicked();
+    void onSaveButtonClicked();
+
+    void onCommitHours(const LLSD& value);
+    void onCommitMinutes(const LLSD& value);
+
+    void resetUI(bool enable_ui);
+    void updateAMPM();
+
+    static bool canUse();
+
+protected:
+    static void requestRegionShcheduleCoro(std::string url, LLHandle<LLFloater> handle);
+    static void setRegionShcheduleCoro(std::string url, LLSD body, LLHandle<LLFloater> handle);
+
+    LLHandle<LLView> mOwnerHandle;
+    F32 mContextConeOpacity{ 0.f };
+
+    LLLineEditor* mHoursLineEditor{nullptr};
+    LLLineEditor* mMinutesLineEditor{ nullptr };
+    LLButton* mPMAMButton{ nullptr };
+    LLButton* mSaveButton{ nullptr };
+    LLButton* mCancelButton{ nullptr };
+
+    bool mTimeAM{ true };
+};
+
+#endif  // LL_LLFLOATERREGIONRESTARTSCHEDULE_H
diff --git a/indra/newview/llviewerregion.cpp b/indra/newview/llviewerregion.cpp
index 7623ab56a5..ac64c47abe 100755
--- a/indra/newview/llviewerregion.cpp
+++ b/indra/newview/llviewerregion.cpp
@@ -3276,6 +3276,7 @@ void LLViewerRegionImpl::buildCapabilityNames(LLSD& capabilityNames)
     capabilityNames.append("VoiceSignalingRequest");
     capabilityNames.append("ReadOfflineMsgs"); // Requires to respond reliably: AcceptFriendship, AcceptGroupInvite, DeclineFriendship, DeclineGroupInvite
     capabilityNames.append("RegionObjects");
+    capabilityNames.append("RegionSchedule");
     capabilityNames.append("RemoteParcelRequest");
     capabilityNames.append("RenderMaterials");
     capabilityNames.append("RequestTextureDownload");
diff --git a/indra/newview/skins/default/xui/en/floater_region_restart_schedule.xml b/indra/newview/skins/default/xui/en/floater_region_restart_schedule.xml
new file mode 100644
index 0000000000..fd04acde35
--- /dev/null
+++ b/indra/newview/skins/default/xui/en/floater_region_restart_schedule.xml
@@ -0,0 +1,278 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<floater
+  height="180"
+  layout="topleft"
+  name="floater_region_restart_schedule"
+  help_topic="Preferences_Graphics_Advanced"
+  single_instance="true"
+  save_rect="true"
+  title="REGION RESTART SCHEDULE"
+  width="300">
+
+<!-- This block shows Advanced Settings -->
+  <floater.string name="am_string">am</floater.string>
+  <floater.string name="pm_string">pm</floater.string>
+
+  <text
+    name="days_general"
+    type="string"
+    follows="left|top"
+    layout="topleft"
+    height="16"
+    top="15"
+    left="20"
+    width="328">
+     Restart the region on following days:
+  </text>
+
+  <check_box
+   name="s_chk"
+   label=""
+   tool_tip="Sunday"
+   follows="left|top"
+   layout="topleft"
+   height="20"
+   width="20"
+   left="60"
+   top_pad="5" />
+
+  <check_box
+   name="m_chk"
+   label=""
+   tool_tip="Monday"
+   follows="left|top"
+   layout="topleft"
+   height="20"
+   width="20"
+   left_pad="5"
+   top_delta="0" />
+
+  <check_box
+   name="t_chk"
+   label=""
+   tool_tip="Tuesday"
+   follows="left|top"
+   layout="topleft"
+   height="20"
+   width="20"
+   left_pad="5"
+   top_delta="0" />
+
+  <check_box
+   name="w_chk"
+   label=""
+   tool_tip="Wednesday"
+   follows="left|top"
+   layout="topleft"
+   height="20"
+   width="20"
+   left_pad="5"
+   top_delta="0" />
+
+  <check_box
+   name="r_chk"
+   label=""
+   tool_tip="Thursday"
+   follows="left|top"
+   layout="topleft"
+   height="20"
+   width="20"
+   left_pad="5"
+   top_delta="0" />
+
+  <check_box
+   name="f_chk"
+   label=""
+   tool_tip="Friday"
+   follows="left|top"
+   layout="topleft"
+   height="20"
+   width="20"
+   left_pad="5"
+   top_delta="0" />
+
+  <check_box
+   name="a_chk"
+   label=""
+   tool_tip="Saturday"
+   follows="left|top"
+   layout="topleft"
+   height="20"
+   width="20"
+   left_pad="5"
+   top_delta="0" />
+
+  <text
+   name="su_label"
+   type="string"
+   follows="left|top"
+   layout="topleft"
+   halign="center"
+   height="16"
+   top_pad="5"
+   left="57"
+   width="25">
+     Su
+  </text>
+
+  <text
+   name="mo_label"
+   type="string"
+   follows="left|top"
+   layout="topleft"
+   halign="center"
+   height="16"
+   top_delta="0"
+   left_pad="0"
+   width="25">
+     Mo
+  </text>
+
+  <text
+   name="tu_label"
+   type="string"
+   follows="left|top"
+   layout="topleft"
+   halign="center"
+   height="16"
+   top_delta="0"
+   left_pad="0"
+   width="25">
+     Tu
+  </text>
+
+  <text
+   name="we_label"
+   type="string"
+   follows="left|top"
+   layout="topleft"
+   halign="center"
+   height="16"
+   top_delta="0"
+   left_pad="1"
+   width="25">
+     We
+  </text>
+
+  <text
+   name="th_label"
+   type="string"
+   follows="left|top"
+   layout="topleft"
+   halign="center"
+   height="16"
+   top_delta="0"
+   left_pad="0"
+   width="25">
+     Th
+  </text>
+
+  <text
+   name="fr_label"
+   type="string"
+   follows="left|top"
+   layout="topleft"
+   halign="center"
+   height="16"
+   top_delta="0"
+   left_pad="0"
+   width="25">
+     Fr
+  </text>
+
+  <text
+   name="sa_label"
+   type="string"
+   follows="left|top"
+   layout="topleft"
+   halign="center"
+   height="16"
+   top_delta="0"
+   left_pad="0"
+   width="25">
+     Sa
+  </text>
+
+  <text
+   name="at_label"
+   type="string"
+   follows="left|top"
+   layout="topleft"
+   halign="right"
+   height="16"
+   top_pad="15"
+   left="30"
+   width="40">
+     at
+  </text>
+  <line_editor
+   name="hours_edt"
+   max_length_bytes="2"
+   follows="left|top"
+   layout="topleft"
+   commit_on_focus_lost="true"
+   height="23"
+   width="40"
+   left_pad="4"
+   top_delta="-5"/>
+  <text
+   name="separator_label"
+   type="string"
+   follows="left|top"
+   layout="topleft"
+   halign="center"
+   height="16"
+   top_delta="5"
+   left_pad="0"
+   width="12">
+     :
+  </text>
+  <line_editor
+   name="minutes_edt"
+   max_length_bytes="2"
+   follows="left|top"
+   layout="topleft"
+   commit_on_focus_lost="true"
+   height="23"
+   width="40"
+   left_pad="0"
+   top_delta="-5"/>
+  <button
+   name="am_pm_btn"
+   label="am"
+   follows="left|top"
+   layout="topleft"
+   height="23"
+   width="40"
+   left_pad="1"
+   top_delta="0"/>
+  <text
+   name="utc_label"
+   type="string"
+   follows="left|top"
+   layout="topleft"
+   height="16"
+   top_delta="5"
+   left_pad="5"
+   width="22">
+     UTC
+  </text>
+  <button
+   name="save_btn"
+   label="Save"
+   follows="top|left"
+   layout="topleft"
+   top="145"
+   left="25"
+   height="25"
+   width="110"/>
+  <button
+   name="cancel_btn"
+   label="Cancel"
+   follows="bottom|right"
+   layout="topleft"
+   left_pad="20"
+   top_delta="0"
+   height="25"
+   width="110"/>
+</floater>
diff --git a/indra/newview/skins/default/xui/en/panel_region_general.xml b/indra/newview/skins/default/xui/en/panel_region_general.xml
index 74d21c436e..6ef1b6e44a 100644
--- a/indra/newview/skins/default/xui/en/panel_region_general.xml
+++ b/indra/newview/skins/default/xui/en/panel_region_general.xml
@@ -270,8 +270,20 @@
      left="250"
      name="manage_telehub_btn"
      top="70"
-     width="150">
+     width="160">
 		<button.commit_callback
          function="RegionInfo.ManageTelehub" />
     </button>
+    <button
+     follows="left|top"
+     height="20"
+     label="Manage Restart Schedule..."
+     layout="topleft"
+     name="manage_restart_btn"
+     top_pad="5"
+     left_delta="0"
+     width="160">
+        <button.commit_callback
+         function="RegionInfo.ManageRestart" />
+    </button>
 </panel>