Merge branch 'develop' into rider/privileged_land

73 files changed, 736 insertions, 1410 deletions

diff --git a/indra/llappearance/lltexlayer.cpp b/indra/llappearance/lltexlayer.cpp
index b3800e6981..7f7eaf1855 100644
--- a/indra/llappearance/lltexlayer.cpp
+++ b/indra/llappearance/lltexlayer.cpp
@@ -1890,7 +1890,10 @@ LLGLTexture* LLTexLayerStaticImageList::getTexture(const std::string& file_name,
 
                 image_raw->copyUnscaledAlphaMask(alpha_image_raw, LLColor4U::black);
             }
-            tex->createGLTexture(0, image_raw, 0, true, LLGLTexture::LOCAL);
+            if (!tex->createGLTexture(0, image_raw, 0, true, LLGLTexture::LOCAL))
+            {
+                LL_WARNS() << "Failed to create GL texture for image: " << file_name << LL_ENDL;
+            }
 
             gGL.getTexUnit(0)->bind(tex);
             tex->setAddressMode(LLTexUnit::TAM_CLAMP);
diff --git a/indra/llappearance/lltexlayerparams.cpp b/indra/llappearance/lltexlayerparams.cpp
index 30551c115d..dd2499cf37 100644
--- a/indra/llappearance/lltexlayerparams.cpp
+++ b/indra/llappearance/lltexlayerparams.cpp
@@ -338,7 +338,10 @@ bool LLTexLayerParamAlpha::render(S32 x, S32 y, S32 width, S32 height)
                 // Create the GL texture, and then hang onto it for future use.
                 if (mNeedsCreateTexture)
                 {
-                    mCachedProcessedTexture->createGLTexture(0, mStaticImageRaw);
+                    if (!mCachedProcessedTexture->createGLTexture(0, mStaticImageRaw))
+                    {
+                        LL_WARNS() << "Failed to create GL texture for image: " << mCachedProcessedTexture->getID() << LL_ENDL;
+                    }
                     mNeedsCreateTexture = false;
                     gGL.getTexUnit(0)->bind(mCachedProcessedTexture);
                     mCachedProcessedTexture->setAddressMode(LLTexUnit::TAM_CLAMP);
diff --git a/indra/llcharacter/CMakeLists.txt b/indra/llcharacter/CMakeLists.txt
index bc45eb474a..c6513cdb66 100644
--- a/indra/llcharacter/CMakeLists.txt
+++ b/indra/llcharacter/CMakeLists.txt
@@ -17,14 +17,12 @@ set(llcharacter_SOURCE_FILES
     lljointsolverrp3.cpp
     llkeyframefallmotion.cpp
     llkeyframemotion.cpp
-    llkeyframemotionparam.cpp
     llkeyframestandmotion.cpp
     llkeyframewalkmotion.cpp
     llmotioncontroller.cpp
     llmotion.cpp
     llmultigesture.cpp
     llpose.cpp
-    llstatemachine.cpp
     lltargetingmotion.cpp
     llvisualparam.cpp
     )
@@ -45,14 +43,12 @@ set(llcharacter_HEADER_FILES
     lljointstate.h
     llkeyframefallmotion.h
     llkeyframemotion.h
-    llkeyframemotionparam.h
     llkeyframestandmotion.h
     llkeyframewalkmotion.h
     llmotion.h
     llmotioncontroller.h
     llmultigesture.h
     llpose.h
-    llstatemachine.h
     lltargetingmotion.h
     llvisualparam.h
     )
diff --git a/indra/llcharacter/llkeyframemotionparam.cpp b/indra/llcharacter/llkeyframemotionparam.cpp
deleted file mode 100644
index e4552b96c9..0000000000
--- a/indra/llcharacter/llkeyframemotionparam.cpp
+++ /dev/null
@@ -1,436 +0,0 @@
-/**
- * @file llkeyframemotionparam.cpp
- * @brief Implementation of LLKeyframeMotion class.
- *
- * $LicenseInfo:firstyear=2001&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-//-----------------------------------------------------------------------------
-// Header Files
-//-----------------------------------------------------------------------------
-#include "linden_common.h"
-
-#include "llkeyframemotionparam.h"
-#include "llcharacter.h"
-#include "llmath.h"
-#include "m3math.h"
-#include "lldir.h"
-#include "llanimationstates.h"
-
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-// LLKeyframeMotionParam class
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-
-//-----------------------------------------------------------------------------
-// LLKeyframeMotionParam()
-// Class Constructor
-//-----------------------------------------------------------------------------
-LLKeyframeMotionParam::LLKeyframeMotionParam( const LLUUID &id) : LLMotion(id)
-{
-    mDefaultKeyframeMotion = NULL;
-    mCharacter = NULL;
-
-    mEaseInDuration = 0.f;
-    mEaseOutDuration = 0.f;
-    mDuration = 0.f;
-    mPriority = LLJoint::LOW_PRIORITY;
-}
-
-
-//-----------------------------------------------------------------------------
-// ~LLKeyframeMotionParam()
-// Class Destructor
-//-----------------------------------------------------------------------------
-LLKeyframeMotionParam::~LLKeyframeMotionParam()
-{
-    for (motion_map_t::value_type& motion_pair : mParameterizedMotions)
-    {
-        motion_list_t& motionList = motion_pair.second;
-        for (const ParameterizedMotion& paramMotion : motionList)
-        {
-            delete paramMotion.mMotion;
-        }
-        motionList.clear();
-    }
-    mParameterizedMotions.clear();
-}
-
-//-----------------------------------------------------------------------------
-// LLKeyframeMotionParam::onInitialize(LLCharacter *character)
-//-----------------------------------------------------------------------------
-LLMotion::LLMotionInitStatus LLKeyframeMotionParam::onInitialize(LLCharacter *character)
-{
-    mCharacter = character;
-
-    if (!loadMotions())
-    {
-        return STATUS_FAILURE;
-    }
-
-    for (motion_map_t::value_type& motion_pair : mParameterizedMotions)
-    {
-        motion_list_t& motionList = motion_pair.second;
-        for (const ParameterizedMotion& paramMotion : motionList)
-        {
-            LLMotion* motion = paramMotion.mMotion;
-            motion->onInitialize(character);
-
-            if (motion->getDuration() > mEaseInDuration)
-            {
-                mEaseInDuration = motion->getEaseInDuration();
-            }
-
-            if (motion->getEaseOutDuration() > mEaseOutDuration)
-            {
-                mEaseOutDuration = motion->getEaseOutDuration();
-            }
-
-            if (motion->getDuration() > mDuration)
-            {
-                mDuration = motion->getDuration();
-            }
-
-            if (motion->getPriority() > mPriority)
-            {
-                mPriority = motion->getPriority();
-            }
-
-            LLPose *pose = motion->getPose();
-
-            mPoseBlender.addMotion(motion);
-            for (LLJointState *jsp = pose->getFirstJointState(); jsp; jsp = pose->getNextJointState())
-            {
-                LLPose *blendedPose = mPoseBlender.getBlendedPose();
-                blendedPose->addJointState(jsp);
-            }
-        }
-    }
-
-    return STATUS_SUCCESS;
-}
-
-//-----------------------------------------------------------------------------
-// LLKeyframeMotionParam::onActivate()
-//-----------------------------------------------------------------------------
-bool LLKeyframeMotionParam::onActivate()
-{
-    for (motion_map_t::value_type& motion_pair : mParameterizedMotions)
-    {
-        motion_list_t& motionList = motion_pair.second;
-        for (const ParameterizedMotion& paramMotion : motionList)
-        {
-            paramMotion.mMotion->activate(mActivationTimestamp);
-        }
-    }
-    return true;
-}
-
-
-//-----------------------------------------------------------------------------
-// LLKeyframeMotionParam::onUpdate()
-//-----------------------------------------------------------------------------
-bool LLKeyframeMotionParam::onUpdate(F32 time, U8* joint_mask)
-{
-    LL_PROFILE_ZONE_SCOPED;
-    F32 weightFactor = 1.f / (F32)mParameterizedMotions.size();
-
-    // zero out all pose weights
-    for (motion_map_t::value_type& motion_pair : mParameterizedMotions)
-    {
-        motion_list_t& motionList = motion_pair.second;
-        for (const ParameterizedMotion& paramMotion : motionList)
-        {
-//          LL_INFOS() << "Weight for pose " << paramMotion.mMotion->getName() << " is " << paramMotion.mMotion->getPose()->getWeight() << LL_ENDL;
-            paramMotion.mMotion->getPose()->setWeight(0.f);
-        }
-    }
-
-
-    for (motion_map_t::value_type& motion_pair : mParameterizedMotions)
-    {
-        const std::string& paramName = motion_pair.first;
-        F32* paramValue = (F32 *)mCharacter->getAnimationData(paramName);
-        if (NULL == paramValue) // unexpected, but...
-        {
-            LL_WARNS() << "paramValue == NULL" << LL_ENDL;
-            continue;
-        }
-
-        // DANGER! Do not modify mParameterizedMotions while using these pointers!
-        const ParameterizedMotion* firstMotion = NULL;
-        const ParameterizedMotion* secondMotion = NULL;
-
-        motion_list_t& motionList = motion_pair.second;
-        for (const ParameterizedMotion& paramMotion : motionList)
-        {
-            paramMotion.mMotion->onUpdate(time, joint_mask);
-
-            F32 distToParam = paramMotion.mParam - *paramValue;
-
-            if ( distToParam <= 0.f)
-            {
-                // keep track of the motion closest to the parameter value
-                firstMotion = &paramMotion;
-            }
-            else
-            {
-                // we've passed the parameter value
-                // so store the first motion we find as the second one we want to blend...
-                if (firstMotion && !secondMotion )
-                {
-                    secondMotion = &paramMotion;
-                }
-                //...or, if we've seen no other motion so far, make sure we blend to this only
-                else if (!firstMotion)
-                {
-                    firstMotion = &paramMotion;
-                    secondMotion = &paramMotion;
-                }
-            }
-        }
-
-        LLPose *firstPose;
-        LLPose *secondPose;
-
-        if (firstMotion)
-            firstPose = firstMotion->mMotion->getPose();
-        else
-            firstPose = NULL;
-
-        if (secondMotion)
-            secondPose = secondMotion->mMotion->getPose();
-        else
-            secondPose = NULL;
-
-        // now modify weight of the subanim (only if we are blending between two motions)
-        if (firstMotion && secondMotion)
-        {
-            if (firstMotion == secondMotion)
-            {
-                firstPose->setWeight(weightFactor);
-            }
-            else if (firstMotion->mParam == secondMotion->mParam)
-            {
-                firstPose->setWeight(0.5f * weightFactor);
-                secondPose->setWeight(0.5f * weightFactor);
-            }
-            else
-            {
-                F32 first_weight = 1.f -
-                    ((llclamp(*paramValue - firstMotion->mParam, 0.f, (secondMotion->mParam - firstMotion->mParam))) /
-                        (secondMotion->mParam - firstMotion->mParam));
-                first_weight = llclamp(first_weight, 0.f, 1.f);
-
-                F32 second_weight = 1.f - first_weight;
-
-                firstPose->setWeight(first_weight * weightFactor);
-                secondPose->setWeight(second_weight * weightFactor);
-
-//              LL_INFOS() << "Parameter " << *paramName << ": " << *paramValue << LL_ENDL;
-//              LL_INFOS() << "Weights " << firstPose->getWeight() << " " << secondPose->getWeight() << LL_ENDL;
-            }
-        }
-        else if (firstMotion && !secondMotion)
-        {
-            firstPose->setWeight(weightFactor);
-        }
-    }
-
-    // blend poses
-    mPoseBlender.blendAndApply();
-
-    LL_INFOS() << "Param Motion weight " << mPoseBlender.getBlendedPose()->getWeight() << LL_ENDL;
-
-    return true;
-}
-
-//-----------------------------------------------------------------------------
-// LLKeyframeMotionParam::onDeactivate()
-//-----------------------------------------------------------------------------
-void LLKeyframeMotionParam::onDeactivate()
-{
-    for (motion_map_t::value_type& motion_pair : mParameterizedMotions)
-    {
-        motion_list_t& motionList = motion_pair.second;
-        for (const ParameterizedMotion& paramMotion : motionList)
-        {
-            paramMotion.mMotion->onDeactivate();
-        }
-    }
-}
-
-//-----------------------------------------------------------------------------
-// LLKeyframeMotionParam::addKeyframeMotion()
-//-----------------------------------------------------------------------------
-bool LLKeyframeMotionParam::addKeyframeMotion(char *name, const LLUUID &id, char *param, F32 value)
-{
-    LLMotion *newMotion = mCharacter->createMotion( id );
-
-    if (!newMotion)
-    {
-        return false;
-    }
-
-    newMotion->setName(name);
-
-    // now add motion to this list
-    mParameterizedMotions[param].insert(ParameterizedMotion(newMotion, value));
-
-    return true;
-}
-
-
-//-----------------------------------------------------------------------------
-// LLKeyframeMotionParam::setDefaultKeyframeMotion()
-//-----------------------------------------------------------------------------
-void LLKeyframeMotionParam::setDefaultKeyframeMotion(char *name)
-{
-    for (motion_map_t::value_type& motion_pair : mParameterizedMotions)
-    {
-        motion_list_t& motionList = motion_pair.second;
-        for (const ParameterizedMotion& paramMotion : motionList)
-        {
-            if (paramMotion.mMotion->getName() == name)
-            {
-                mDefaultKeyframeMotion = paramMotion.mMotion;
-            }
-        }
-    }
-}
-
-//-----------------------------------------------------------------------------
-// loadMotions()
-//-----------------------------------------------------------------------------
-bool LLKeyframeMotionParam::loadMotions()
-{
-    //-------------------------------------------------------------------------
-    // Load named file by concatenating the character prefix with the motion name.
-    // Load data into a buffer to be parsed.
-    //-------------------------------------------------------------------------
-    //std::string path = gDirUtilp->getExpandedFilename(LL_PATH_MOTIONS,mCharacter->getAnimationPrefix())
-    //  + "_" + getName() + ".llp";
-    //RN: deprecated unused reference to "motion" directory
-    std::string path;
-
-
-    //-------------------------------------------------------------------------
-    // open the file
-    //-------------------------------------------------------------------------
-    S32 fileSize = 0;
-    LLAPRFile infile ;
-    infile.open(path, LL_APR_R, NULL, &fileSize);
-    apr_file_t* fp = infile.getFileHandle() ;
-    if (!fp || fileSize == 0)
-    {
-        LL_INFOS() << "ERROR: can't open: " << path << LL_ENDL;
-        return false;
-    }
-
-    // allocate a text buffer
-    std::vector<char> text(fileSize+1);
-
-    //-------------------------------------------------------------------------
-    // load data from file into buffer
-    //-------------------------------------------------------------------------
-    bool error = false;
-    char *p = &text[0];
-    while ( 1 )
-    {
-        if (apr_file_eof(fp) == APR_EOF)
-        {
-            break;
-        }
-        if (apr_file_gets(p, 1024, fp) != APR_SUCCESS)
-        {
-            error = true;
-            break;
-        }
-        while ( *(++p) )
-            ;
-    }
-
-    //-------------------------------------------------------------------------
-    // close the file
-    //-------------------------------------------------------------------------
-    infile.close();
-
-    //-------------------------------------------------------------------------
-    // check for error
-    //-------------------------------------------------------------------------
-    llassert( p <= (&text[0] + fileSize) );
-
-    if ( error )
-    {
-        LL_INFOS() << "ERROR: error while reading from " << path << LL_ENDL;
-        return false;
-    }
-
-    LL_INFOS() << "Loading parametric keyframe data for: " << getName() << LL_ENDL;
-
-    //-------------------------------------------------------------------------
-    // parse the text and build keyframe data structures
-    //-------------------------------------------------------------------------
-    p = &text[0];
-    S32 num;
-    char strA[80]; /* Flawfinder: ignore */
-    char strB[80]; /* Flawfinder: ignore */
-    F32 floatA = 0.0f;
-
-
-    //-------------------------------------------------------------------------
-    // get priority
-    //-------------------------------------------------------------------------
-    bool isFirstMotion = true;
-    num = sscanf(p, "%79s %79s %f", strA, strB, &floatA);   /* Flawfinder: ignore */
-
-    while(1)
-    {
-        if (num == 0 || num == EOF) break;
-        if ((num != 3))
-        {
-            LL_INFOS() << "WARNING: can't read parametric motion" << LL_ENDL;
-            return false;
-        }
-
-        addKeyframeMotion(strA, gAnimLibrary.stringToAnimState(std::string(strA)), strB, floatA);
-        if (isFirstMotion)
-        {
-            isFirstMotion = false;
-            setDefaultKeyframeMotion(strA);
-        }
-
-        p = strstr(p, "\n");
-        if (!p)
-        {
-            break;
-        }
-
-        p++;
-        num = sscanf(p, "%79s %79s %f", strA, strB, &floatA);   /* Flawfinder: ignore */
-    }
-
-    return true;
-}
-
-// End
diff --git a/indra/llcharacter/llkeyframemotionparam.h b/indra/llcharacter/llkeyframemotionparam.h
deleted file mode 100644
index 8c57766e9b..0000000000
--- a/indra/llcharacter/llkeyframemotionparam.h
+++ /dev/null
@@ -1,169 +0,0 @@
-/**
- * @file llkeyframemotionparam.h
- * @brief Implementation of LLKeframeMotionParam class.
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLKEYFRAMEMOTIONPARAM_H
-#define LL_LLKEYFRAMEMOTIONPARAM_H
-
-//-----------------------------------------------------------------------------
-// Header files
-//-----------------------------------------------------------------------------
-
-#include <string>
-
-#include "llmotion.h"
-#include "lljointstate.h"
-#include "v3math.h"
-#include "llquaternion.h"
-#include "llkeyframemotion.h"
-
-//-----------------------------------------------------------------------------
-// class LLKeyframeMotionParam
-//-----------------------------------------------------------------------------
-class LLKeyframeMotionParam :
-    public LLMotion
-{
-public:
-    // Constructor
-    LLKeyframeMotionParam(const LLUUID &id);
-
-    // Destructor
-    virtual ~LLKeyframeMotionParam();
-
-public:
-    //-------------------------------------------------------------------------
-    // functions to support MotionController and MotionRegistry
-    //-------------------------------------------------------------------------
-
-    // static constructor
-    // all subclasses must implement such a function and register it
-    static LLMotion *create(const LLUUID &id) { return new LLKeyframeMotionParam(id); }
-
-public:
-    //-------------------------------------------------------------------------
-    // animation callbacks to be implemented by subclasses
-    //-------------------------------------------------------------------------
-
-    // motions must specify whether or not they loop
-    virtual bool getLoop() {
-        return true;
-    }
-
-    // motions must report their total duration
-    virtual F32 getDuration() {
-        return mDuration;
-    }
-
-    // motions must report their "ease in" duration
-    virtual F32 getEaseInDuration() {
-        return mEaseInDuration;
-    }
-
-    // motions must report their "ease out" duration.
-    virtual F32 getEaseOutDuration() {
-        return mEaseOutDuration;
-    }
-
-    // motions must report their priority
-    virtual LLJoint::JointPriority getPriority() {
-        return mPriority;
-    }
-
-    virtual LLMotionBlendType getBlendType() { return NORMAL_BLEND; }
-
-    // called to determine when a motion should be activated/deactivated based on avatar pixel coverage
-    virtual F32 getMinPixelArea() { return MIN_REQUIRED_PIXEL_AREA_KEYFRAME; }
-
-    // run-time (post constructor) initialization,
-    // called after parameters have been set
-    // must return true to indicate success and be available for activation
-    virtual LLMotionInitStatus onInitialize(LLCharacter *character);
-
-    // called when a motion is activated
-    // must return true to indicate success, or else
-    // it will be deactivated
-    virtual bool onActivate();
-
-    // called per time step
-    // must return true while it is active, and
-    // must return false when the motion is completed.
-    virtual bool onUpdate(F32 time, U8* joint_mask);
-
-    // called when a motion is deactivated
-    virtual void onDeactivate();
-
-    virtual LLPose* getPose() { return mPoseBlender.getBlendedPose();}
-
-protected:
-    //-------------------------------------------------------------------------
-    // new functions defined by this subclass
-    //-------------------------------------------------------------------------
-    struct ParameterizedMotion
-    {
-        ParameterizedMotion(LLMotion* motion, F32 param) : mMotion(motion), mParam(param) {}
-        LLMotion* mMotion;
-        F32 mParam;
-    };
-
-    // add a motion and associated parameter triplet
-    bool addKeyframeMotion(char *name, const LLUUID &id, char *param, F32 value);
-
-    // set default motion for LOD and retrieving blend constants
-    void setDefaultKeyframeMotion(char *);
-
-    bool loadMotions();
-
-protected:
-    //-------------------------------------------------------------------------
-    // Member Data
-    //-------------------------------------------------------------------------
-
-    struct compare_motions
-    {
-        bool operator() (const ParameterizedMotion& a, const ParameterizedMotion& b) const
-        {
-            if (a.mParam != b.mParam)
-                return (a.mParam < b.mParam);
-            else
-                return a.mMotion < b.mMotion;
-        }
-    };
-
-    typedef std::set < ParameterizedMotion, compare_motions > motion_list_t;
-    typedef std::map <std::string, motion_list_t > motion_map_t;
-    motion_map_t        mParameterizedMotions;
-    LLMotion*           mDefaultKeyframeMotion;
-    LLCharacter*        mCharacter;
-    LLPoseBlender       mPoseBlender;
-
-    F32                 mEaseInDuration;
-    F32                 mEaseOutDuration;
-    F32                 mDuration;
-    LLJoint::JointPriority  mPriority;
-
-    LLUUID              mTransactionID;
-};
-
-#endif // LL_LLKEYFRAMEMOTIONPARAM_H
diff --git a/indra/llcharacter/llmotioncontroller.h b/indra/llcharacter/llmotioncontroller.h
index 0c262bf24a..c2cb174821 100644
--- a/indra/llcharacter/llmotioncontroller.h
+++ b/indra/llcharacter/llmotioncontroller.h
@@ -37,7 +37,6 @@
 #include "llmotion.h"
 #include "llpose.h"
 #include "llframetimer.h"
-#include "llstatemachine.h"
 #include "llstring.h"
 
 //-----------------------------------------------------------------------------
diff --git a/indra/llcharacter/llstatemachine.cpp b/indra/llcharacter/llstatemachine.cpp
deleted file mode 100644
index 38e9ef444c..0000000000
--- a/indra/llcharacter/llstatemachine.cpp
+++ /dev/null
@@ -1,384 +0,0 @@
-/**
- * @file llstatemachine.cpp
- * @brief LLStateMachine implementation file.
- *
- * $LicenseInfo:firstyear=2001&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-
-#include "llstatemachine.h"
-#include "llapr.h"
-
-#define FSM_PRINT_STATE_TRANSITIONS (0)
-
-U32 LLUniqueID::sNextID = 0;
-
-bool    operator==(const LLUniqueID &a, const LLUniqueID &b)
-{
-    return (a.mId == b.mId);
-}
-
-bool    operator!=(const LLUniqueID &a, const LLUniqueID &b)
-{
-    return (a.mId != b.mId);
-}
-
-//-----------------------------------------------------------------------------
-// LLStateDiagram
-//-----------------------------------------------------------------------------
-LLStateDiagram::LLStateDiagram()
-{
-    mDefaultState = NULL;
-    mUseDefaultState = false;
-}
-
-LLStateDiagram::~LLStateDiagram()
-{
-
-}
-
-// add a state to the state graph
-bool LLStateDiagram::addState(LLFSMState *state)
-{
-    mStates[state] = Transitions();
-    return true;
-}
-
-// add a directed transition between 2 states
-bool LLStateDiagram::addTransition(LLFSMState& start_state, LLFSMState& end_state, LLFSMTransition& transition)
-{
-    StateMap::iterator state_it;
-    state_it = mStates.find(&start_state);
-    Transitions* state_transitions = NULL;
-    if (state_it == mStates.end() )
-    {
-        addState(&start_state);
-        state_transitions = &mStates[&start_state];
-    }
-    else
-    {
-        state_transitions = &state_it->second;
-    }
-    state_it = mStates.find(&end_state);
-    if (state_it == mStates.end() )
-    {
-        addState(&end_state);
-    }
-
-    Transitions::iterator transition_it = state_transitions->find(&transition);
-    if (transition_it != state_transitions->end())
-    {
-        LL_ERRS() << "LLStateTable::addDirectedTransition() : transition already exists" << LL_ENDL;
-        return false; // transition already exists
-    }
-
-    (*state_transitions)[&transition] = &end_state;
-    return true;
-}
-
-// add an undirected transition between 2 states
-bool LLStateDiagram::addUndirectedTransition(LLFSMState& start_state, LLFSMState& end_state, LLFSMTransition& transition)
-{
-    bool result;
-    result = addTransition(start_state, end_state, transition);
-    if (result)
-    {
-        result = addTransition(end_state, start_state, transition);
-    }
-    return result;
-}
-
-// add a transition that exists for every state
-void LLStateDiagram::addDefaultTransition(LLFSMState& end_state, LLFSMTransition& transition)
-{
-    mDefaultTransitions[&transition] = &end_state;
-}
-
-// process a possible transition, and get the resulting state
-LLFSMState* LLStateDiagram::processTransition(LLFSMState& start_state, LLFSMTransition& transition)
-{
-    // look up transition
-    //LLFSMState** dest_state = (mStates.getValue(&start_state))->getValue(&transition);
-    LLFSMState* dest_state = NULL;
-    StateMap::iterator state_it = mStates.find(&start_state);
-    if (state_it == mStates.end())
-    {
-        return NULL;
-    }
-    Transitions::iterator transition_it = state_it->second.find(&transition);
-
-    // try default transitions if state-specific transition not found
-    if (transition_it == state_it->second.end())
-    {
-        dest_state = mDefaultTransitions[&transition];
-    }
-    else
-    {
-        dest_state = transition_it->second;
-    }
-
-    // if we have a destination state...
-    if (NULL != dest_state)
-    {
-        // ...return it...
-        return dest_state;
-    }
-    // ... otherwise ...
-    else
-    {
-        // ...look for default state...
-        if (mUseDefaultState)
-        {
-            // ...return it if we have it...
-            return mDefaultState;
-        }
-        else
-        {
-            // ...or else we're still in the same state.
-            return &start_state;
-        }
-    }
-}
-
-void LLStateDiagram::setDefaultState(LLFSMState& default_state)
-{
-    mUseDefaultState = true;
-    mDefaultState = &default_state;
-}
-
-S32 LLStateDiagram::numDeadendStates()
-{
-    S32 numDeadends = 0;
-    for (StateMap::value_type& state_pair : mStates)
-    {
-        if (state_pair.second.size() == 0)
-        {
-            numDeadends++;
-        }
-    }
-    return numDeadends;
-}
-
-bool LLStateDiagram::stateIsValid(LLFSMState& state)
-{
-    if (mStates.find(&state) != mStates.end())
-    {
-        return true;
-    }
-    return false;
-}
-
-LLFSMState* LLStateDiagram::getState(U32 state_id)
-{
-    for (StateMap::value_type& state_pair : mStates)
-    {
-        if (state_pair.first->getID() == state_id)
-        {
-            return state_pair.first;
-        }
-    }
-    return NULL;
-}
-
-bool LLStateDiagram::saveDotFile(const std::string& filename)
-{
-    LLAPRFile outfile ;
-    outfile.open(filename, LL_APR_W);
-    apr_file_t* dot_file = outfile.getFileHandle() ;
-
-    if (!dot_file)
-    {
-        LL_WARNS() << "LLStateDiagram::saveDotFile() : Couldn't open " << filename << " to save state diagram." << LL_ENDL;
-        return false;
-    }
-    apr_file_printf(dot_file, "digraph StateMachine {\n\tsize=\"100,100\";\n\tfontsize=40;\n\tlabel=\"Finite State Machine\";\n\torientation=landscape\n\tratio=.77\n");
-
-    for (StateMap::value_type& state_pair : mStates)
-    {
-        apr_file_printf(dot_file, "\t\"%s\" [fontsize=28,shape=box]\n", state_pair.first->getName().c_str());
-    }
-    apr_file_printf(dot_file, "\t\"All States\" [fontsize=30,style=bold,shape=box]\n");
-
-    for (Transitions::value_type& transition_pair : mDefaultTransitions)
-    {
-        apr_file_printf(dot_file, "\t\"All States\" -> \"%s\" [label = \"%s\",fontsize=24];\n", transition_pair.second->getName().c_str(),
-            transition_pair.second->getName().c_str());
-    }
-
-    if (mDefaultState)
-    {
-        apr_file_printf(dot_file, "\t\"All States\" -> \"%s\";\n", mDefaultState->getName().c_str());
-    }
-
-
-    for (StateMap::value_type& state_pair : mStates)
-    {
-        LLFSMState *state = state_pair.first;
-
-        for (Transitions::value_type& transition_pair : state_pair.second)
-        {
-            std::string state_name = state->getName();
-            std::string target_name = transition_pair.second->getName();
-            std::string transition_name = transition_pair.first->getName();
-            apr_file_printf(dot_file, "\t\"%s\" -> \"%s\" [label = \"%s\",fontsize=24];\n", state->getName().c_str(),
-                target_name.c_str(),
-                transition_name.c_str());
-        }
-    }
-
-    apr_file_printf(dot_file, "}\n");
-
-    return true;
-}
-
-std::ostream& operator<<(std::ostream &s, LLStateDiagram &FSM)
-{
-    if (FSM.mDefaultState)
-    {
-        s << "Default State: " << FSM.mDefaultState->getName() << "\n";
-    }
-
-    for (LLStateDiagram::Transitions::value_type& transition_pair : FSM.mDefaultTransitions)
-    {
-        s << "Any State -- " << transition_pair.first->getName()
-            << " --> " << transition_pair.second->getName() << "\n";
-    }
-
-    for (LLStateDiagram::StateMap::value_type& state_pair : FSM.mStates)
-    {
-        for (LLStateDiagram::Transitions::value_type& transition_pair : state_pair.second)
-        {
-            s << state_pair.first->getName() << " -- " << transition_pair.first->getName()
-                << " --> " << transition_pair.second->getName() << "\n";
-        }
-        s << "\n";
-    }
-
-    return s;
-}
-
-//-----------------------------------------------------------------------------
-// LLStateMachine
-//-----------------------------------------------------------------------------
-
-LLStateMachine::LLStateMachine()
-{
-    // we haven't received a starting state yet
-    mCurrentState = NULL;
-    mLastState = NULL;
-    mLastTransition = NULL;
-    mStateDiagram = NULL;
-}
-
-LLStateMachine::~LLStateMachine()
-{
-
-}
-
-// returns current state
-LLFSMState* LLStateMachine::getCurrentState() const
-{
-    return mCurrentState;
-}
-
-// executes current state
-void LLStateMachine::runCurrentState(void *data)
-{
-    mCurrentState->execute(data);
-}
-
-// set current state
-bool LLStateMachine::setCurrentState(LLFSMState *initial_state, void* user_data, bool skip_entry)
-{
-    llassert(mStateDiagram);
-
-    if (mStateDiagram->stateIsValid(*initial_state))
-    {
-        mLastState = mCurrentState = initial_state;
-        if (!skip_entry)
-        {
-            initial_state->onEntry(user_data);
-        }
-        return true;
-    }
-
-    return false;
-}
-
-bool LLStateMachine::setCurrentState(U32 state_id, void* user_data, bool skip_entry)
-{
-    llassert(mStateDiagram);
-
-    LLFSMState* state = mStateDiagram->getState(state_id);
-
-    if (state)
-    {
-        mLastState = mCurrentState = state;
-        if (!skip_entry)
-        {
-            state->onEntry(user_data);
-        }
-        return true;
-    }
-
-    return false;
-}
-
-void LLStateMachine::processTransition(LLFSMTransition& transition, void* user_data)
-{
-    llassert(mStateDiagram);
-
-    if (NULL == mCurrentState)
-    {
-        LL_WARNS() << "mCurrentState == NULL; aborting processTransition()" << LL_ENDL;
-        return;
-    }
-
-    LLFSMState* new_state = mStateDiagram->processTransition(*mCurrentState, transition);
-
-    if (NULL == new_state)
-    {
-        LL_WARNS() << "new_state == NULL; aborting processTransition()" << LL_ENDL;
-        return;
-    }
-
-    mLastTransition = &transition;
-    mLastState = mCurrentState;
-
-    if (*mCurrentState != *new_state)
-    {
-        mCurrentState->onExit(user_data);
-        mCurrentState = new_state;
-        mCurrentState->onEntry(user_data);
-#if FSM_PRINT_STATE_TRANSITIONS
-        LL_INFOS() << "Entering state " << mCurrentState->getName() <<
-            " on transition " << transition.getName() << " from state " <<
-            mLastState->getName() << LL_ENDL;
-#endif
-    }
-}
-
-void LLStateMachine::setStateDiagram(LLStateDiagram* diagram)
-{
-    mStateDiagram = diagram;
-}
diff --git a/indra/llcharacter/llstatemachine.h b/indra/llcharacter/llstatemachine.h
deleted file mode 100644
index 9a33798d96..0000000000
--- a/indra/llcharacter/llstatemachine.h
+++ /dev/null
@@ -1,147 +0,0 @@
-/**
- * @file llstatemachine.h
- * @brief LLStateMachine class header file.
- *
- * $LicenseInfo:firstyear=2001&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLSTATEMACHINE_H
-#define LL_LLSTATEMACHINE_H
-
-#include <string>
-
-#include "llerror.h"
-#include <map>
-
-class LLUniqueID
-{
-    friend bool operator==(const LLUniqueID &a, const LLUniqueID &b);
-    friend bool operator!=(const LLUniqueID &a, const LLUniqueID &b);
-protected:
-    static U32  sNextID;
-    U32         mId;
-public:
-    LLUniqueID(){mId = sNextID++;}
-    virtual ~LLUniqueID(){}
-    U32     getID() {return mId;}
-};
-
-class LLFSMTransition : public LLUniqueID
-{
-public:
-    LLFSMTransition() : LLUniqueID(){};
-    virtual std::string getName()const { return "unnamed"; }
-};
-
-class LLFSMState : public LLUniqueID
-{
-public:
-    LLFSMState() : LLUniqueID(){};
-    virtual void onEntry(void *){};
-    virtual void onExit(void *){};
-    virtual void execute(void *){};
-    virtual std::string getName() const { return "unnamed"; }
-};
-
-class LLStateDiagram
-{
-typedef std::map<LLFSMTransition*, LLFSMState*> Transitions;
-
-friend std::ostream& operator<<(std::ostream &s, LLStateDiagram &FSM);
-friend class LLStateMachine;
-
-protected:
-    typedef std::map<LLFSMState*, Transitions> StateMap;
-    StateMap            mStates;
-    Transitions         mDefaultTransitions;
-    LLFSMState*         mDefaultState;
-    bool                mUseDefaultState;
-
-public:
-    LLStateDiagram();
-    virtual ~LLStateDiagram();
-
-protected:
-    // add a state to the state graph, executed implicitly when adding transitions
-    bool addState(LLFSMState *state);
-
-    // add a directed transition between 2 states
-    bool addTransition(LLFSMState& start_state, LLFSMState& end_state, LLFSMTransition& transition);
-
-    // add an undirected transition between 2 states
-    bool addUndirectedTransition(LLFSMState& start_state, LLFSMState& end_state, LLFSMTransition& transition);
-
-    // add a transition that is taken if none other exist
-    void addDefaultTransition(LLFSMState& end_state, LLFSMTransition& transition);
-
-    // process a possible transition, and get the resulting state
-    LLFSMState* processTransition(LLFSMState& start_state, LLFSMTransition& transition);
-
-    // add a transition that exists for every state
-    void setDefaultState(LLFSMState& default_state);
-
-    // return total number of states with no outgoing transitions
-    S32 numDeadendStates();
-
-    // does this state exist in the state diagram?
-    bool stateIsValid(LLFSMState& state);
-
-    // get a state pointer by ID
-    LLFSMState* getState(U32 state_id);
-
-public:
-    // save the graph in a DOT file for rendering and visualization
-    bool saveDotFile(const std::string& filename);
-};
-
-class LLStateMachine
-{
-protected:
-    LLFSMState*         mCurrentState;
-    LLFSMState*         mLastState;
-    LLFSMTransition*    mLastTransition;
-    LLStateDiagram*     mStateDiagram;
-
-public:
-    LLStateMachine();
-    virtual ~LLStateMachine();
-
-    // set state diagram
-    void setStateDiagram(LLStateDiagram* diagram);
-
-    // process this transition
-    void processTransition(LLFSMTransition &transition, void* user_data);
-
-    // returns current state
-    LLFSMState* getCurrentState() const;
-
-    // execute current state
-    void runCurrentState(void *data);
-
-    // set state by state pointer
-    bool setCurrentState(LLFSMState *initial_state, void* user_data, bool skip_entry = true);
-
-    // set state by unique ID
-    bool setCurrentState(U32 state_id, void* user_data, bool skip_entry = true);
-};
-
-#endif //_LL_LLSTATEMACHINE_H
diff --git a/indra/llcommon/llqueuedthread.cpp b/indra/llcommon/llqueuedthread.cpp
index 0196a24b18..efeeb1340e 100644
--- a/indra/llcommon/llqueuedthread.cpp
+++ b/indra/llcommon/llqueuedthread.cpp
@@ -80,7 +80,7 @@ void LLQueuedThread::shutdown()
             mRequestQueue.close();
         }
 
-        S32 timeout = 100;
+        S32 timeout = 50;
         for ( ; timeout>0; timeout--)
         {
             if (isStopped())
@@ -101,19 +101,34 @@ void LLQueuedThread::shutdown()
     }
 
     QueuedRequest* req;
-    S32 active_count = 0;
+    S32 queued_count = 0;
+    bool  has_active = false;
+    lockData();
     while ( (req = (QueuedRequest*)mRequestHash.pop_element()) )
     {
-        if (req->getStatus() == STATUS_QUEUED || req->getStatus() == STATUS_INPROGRESS)
+        if (req->getStatus() == STATUS_INPROGRESS)
+        {
+            has_active = true;
+            req->setFlags(FLAG_ABORT | FLAG_AUTO_COMPLETE);
+            continue;
+        }
+        if (req->getStatus() == STATUS_QUEUED)
         {
-            ++active_count;
+            ++queued_count;
             req->setStatus(STATUS_ABORTED); // avoid assert in deleteRequest
         }
         req->deleteRequest();
     }
-    if (active_count)
+    unlockData();
+    if (queued_count)
+    {
+        LL_WARNS() << "~LLQueuedThread() called with unpocessed requests: " << queued_count << LL_ENDL;
+    }
+    if (has_active)
     {
-        LL_WARNS() << "~LLQueuedThread() called with active requests: " << active_count << LL_ENDL;
+        LL_WARNS() << "~LLQueuedThread() called with active requests!" << LL_ENDL;
+        ms_sleep(100); // last chance for request to finish
+        printQueueStats();
     }
 
     mRequestQueue.close();
@@ -570,7 +585,12 @@ LLQueuedThread::QueuedRequest::QueuedRequest(LLQueuedThread::handle_t handle, U3
 
 LLQueuedThread::QueuedRequest::~QueuedRequest()
 {
-    llassert_always(mStatus == STATUS_DELETE);
+    if (mStatus != STATUS_DELETE)
+    {
+        // The only method to delete a request is deleteRequest(),
+        // it should have set the status to STATUS_DELETE
+        LL_ERRS() << "LLQueuedThread::QueuedRequest deleted with status " << mStatus << LL_ENDL;
+    }
 }
 
 //virtual
diff --git a/indra/llcommon/lluriparser.cpp b/indra/llcommon/lluriparser.cpp
index 33a48d970d..1d246bb70e 100644
--- a/indra/llcommon/lluriparser.cpp
+++ b/indra/llcommon/lluriparser.cpp
@@ -33,7 +33,7 @@ LLUriParser::LLUriParser(const std::string& u) : mTmpScheme(false), mNormalizedT
 {
     if (u.find("://") == std::string::npos)
     {
-        mNormalizedUri = "http://";
+        mNormalizedUri = "https://";
         mTmpScheme = true;
     }
 
diff --git a/indra/llcommon/workqueue.cpp b/indra/llcommon/workqueue.cpp
index 7efaebd569..4db44ff2a6 100644
--- a/indra/llcommon/workqueue.cpp
+++ b/indra/llcommon/workqueue.cpp
@@ -276,12 +276,30 @@ bool LL::WorkQueue::done()
 
 bool LL::WorkQueue::post(const Work& callable)
 {
-    return mQueue.pushIfOpen(callable);
+    try
+    {
+        return mQueue.pushIfOpen(callable);
+    }
+    catch (std::bad_alloc&)
+    {
+        LLError::LLUserWarningMsg::showOutOfMemory();
+        LL_ERRS("LLCoros") << "Bad memory allocation in WorkQueue::post" << LL_ENDL;
+        return false;
+    }
 }
 
 bool LL::WorkQueue::tryPost(const Work& callable)
 {
-    return mQueue.tryPush(callable);
+    try
+    {
+        return mQueue.tryPush(callable);
+    }
+    catch (std::bad_alloc&)
+    {
+        LLError::LLUserWarningMsg::showOutOfMemory();
+        LL_ERRS("LLCoros") << "Bad memory allocation in WorkQueue::tryPost" << LL_ENDL;
+        return false;
+    }
 }
 
 LL::WorkQueue::Work LL::WorkQueue::pop_()
diff --git a/indra/llplugin/llpluginprocessparent.cpp b/indra/llplugin/llpluginprocessparent.cpp
index 02c7d9507d..4f55d75e7d 100644
--- a/indra/llplugin/llpluginprocessparent.cpp
+++ b/indra/llplugin/llpluginprocessparent.cpp
@@ -982,15 +982,18 @@ void LLPluginProcessParent::poll(F64 timeout)
         }
     }
 
-    // Remove instances in the done state from the sInstances map.
-    LLCoros::LockType lock(*sInstancesMutex);
-    mapInstances_t::iterator itClean = sInstances.begin();
-    while (itClean != sInstances.end())
+    if (sInstancesMutex)
     {
-        if ((*itClean).second->isDone())
-            itClean = sInstances.erase(itClean);
-        else
-            ++itClean;
+        // Remove instances in the done state from the sInstances map.
+        LLCoros::LockType lock(*sInstancesMutex);
+        mapInstances_t::iterator itClean = sInstances.begin();
+        while (itClean != sInstances.end())
+        {
+            if ((*itClean).second->isDone())
+                itClean = sInstances.erase(itClean);
+            else
+                ++itClean;
+        }
     }
 }
 
diff --git a/indra/llprimitive/llmediaentry.cpp b/indra/llprimitive/llmediaentry.cpp
index b5b17c53aa..48c6ba1fa5 100644
--- a/indra/llprimitive/llmediaentry.cpp
+++ b/indra/llprimitive/llmediaentry.cpp
@@ -74,7 +74,7 @@ const char* LLMediaEntry::WHITELIST_KEY         = MEDIA_WHITELIST_KEY_STR;
 const char* LLMediaEntry::PERMS_INTERACT_KEY    = MEDIA_PERMS_INTERACT_KEY_STR;
 const char* LLMediaEntry::PERMS_CONTROL_KEY     = MEDIA_PERMS_CONTROL_KEY_STR;
 
-#define DEFAULT_URL_PREFIX  "http://"
+#define DEFAULT_URL_PREFIX  "https://"
 
 // Constructor(s)
 LLMediaEntry::LLMediaEntry() :
diff --git a/indra/llrender/llcubemap.cpp b/indra/llrender/llcubemap.cpp
index 26e4aaad52..b15cec5804 100644
--- a/indra/llrender/llcubemap.cpp
+++ b/indra/llrender/llcubemap.cpp
@@ -86,7 +86,10 @@ void LLCubeMap::initGL()
             #endif
                 mImages[i]->setTarget(mTargets[i], LLTexUnit::TT_CUBE_MAP);
                 mRawImages[i] = new LLImageRaw(RESOLUTION, RESOLUTION, 4);
-                mImages[i]->createGLTexture(0, mRawImages[i], texname);
+                if (!mImages[i]->createGLTexture(0, mRawImages[i], texname))
+                {
+                    LL_WARNS() << "Failed to create GL texture for environment cubemap face " << i << LL_ENDL;
+                }
 
                 gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_CUBE_MAP, texname);
                 mImages[i]->setAddressMode(LLTexUnit::TAM_CLAMP);
@@ -203,7 +206,10 @@ void LLCubeMap::initEnvironmentMap(const std::vector<LLPointer<LLImageRaw> >& ra
         mImages[i] = new LLImageGL(resolution, resolution, components, true);
         mImages[i]->setTarget(mTargets[i], LLTexUnit::TT_CUBE_MAP);
         mRawImages[i] = rawimages[i];
-        mImages[i]->createGLTexture(0, mRawImages[i], texname);
+        if (!mImages[i]->createGLTexture(0, mRawImages[i], texname))
+        {
+            LL_WARNS() << "Failed to create GL texture for environment cubemap face " << i << LL_ENDL;
+        }
 
         gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_CUBE_MAP, texname);
         mImages[i]->setAddressMode(LLTexUnit::TAM_CLAMP);
diff --git a/indra/llrender/llglslshader.cpp b/indra/llrender/llglslshader.cpp
index 9cd5dc8145..a268ea07bb 100644
--- a/indra/llrender/llglslshader.cpp
+++ b/indra/llrender/llglslshader.cpp
@@ -57,6 +57,7 @@ S32 LLGLSLShader::sIndexedTextureChannels = 0;
 U32 LLGLSLShader::sMaxGLTFMaterials = 0;
 U32 LLGLSLShader::sMaxGLTFNodes = 0;
 bool LLGLSLShader::sProfileEnabled = false;
+bool LLGLSLShader::sCanProfile = true;
 std::set<LLGLSLShader*> LLGLSLShader::sInstances;
 LLGLSLShader::defines_map_t LLGLSLShader::sGlobalDefines;
 U64 LLGLSLShader::sTotalTimeElapsed = 0;
@@ -267,7 +268,7 @@ void LLGLSLShader::placeProfileQuery(bool for_runtime)
 
 bool LLGLSLShader::readProfileQuery(bool for_runtime, bool force_read)
 {
-    if (sProfileEnabled || for_runtime)
+    if ((sProfileEnabled || for_runtime) && sCanProfile)
     {
         if (!mProfilePending)
         {
diff --git a/indra/llrender/llglslshader.h b/indra/llrender/llglslshader.h
index 4702a27cc5..272a99aaa5 100644
--- a/indra/llrender/llglslshader.h
+++ b/indra/llrender/llglslshader.h
@@ -160,6 +160,7 @@ public:
 
     static std::set<LLGLSLShader*> sInstances;
     static bool sProfileEnabled;
+    static bool sCanProfile;
 
     LLGLSLShader();
     ~LLGLSLShader();
diff --git a/indra/llui/llaccordionctrl.cpp b/indra/llui/llaccordionctrl.cpp
index 8dcc809dfe..ac8f7c2126 100644
--- a/indra/llui/llaccordionctrl.cpp
+++ b/indra/llui/llaccordionctrl.cpp
@@ -309,11 +309,8 @@ void LLAccordionCtrl::ctrlSetLeftTopAndSize(LLView* panel, S32 left, S32 top, S3
         return;
     LLRect panel_rect = panel->getRect();
     panel_rect.setLeftTopAndSize( left, top, width, height);
-    if (panel->getRect() != panel_rect)
-    {
-        panel->reshape( width, height, 1);
-        panel->setRect(panel_rect);
-    }
+    panel->reshape( width, height, 1);
+    panel->setRect(panel_rect);
 }
 
 void LLAccordionCtrl::ctrlShiftVertical(LLView* panel, S32 delta)
diff --git a/indra/llui/llaccordionctrltab.cpp b/indra/llui/llaccordionctrltab.cpp
index bdf93348bb..828bfb289b 100644
--- a/indra/llui/llaccordionctrltab.cpp
+++ b/indra/llui/llaccordionctrltab.cpp
@@ -479,7 +479,34 @@ void LLAccordionCtrlTab::onUpdateScrollToChild(const LLUICtrl *cntrl)
         // Translate to parent coordinatess to check if we are in visible rectangle
         rect.translate(getRect().mLeft, getRect().mBottom);
 
-        if (!getRect().contains(rect))
+        bool needs_to_scroll = false;
+        const LLRect &acc_rect = getRect();
+        if (!acc_rect.contains(rect))
+        {
+            if (acc_rect.mTop < rect.mBottom || acc_rect.mBottom > rect.mTop)
+            {
+                // Content fully not in view
+                needs_to_scroll = true;
+            }
+            else if (acc_rect.getHeight() >= rect.getHeight())
+            {
+                // Content can be displayed fully, but only partially in view
+                needs_to_scroll = true;
+            }
+            else if (acc_rect.mTop <= rect.mTop || acc_rect.mBottom >= rect.mBottom)
+            {
+                // Intersects, but too big to be displayed fully
+                S32 covered_height = acc_rect.mTop > rect.mTop ? rect.mTop - acc_rect.mBottom : acc_rect.mTop - rect.mBottom;
+                constexpr F32 covered_ratio = 0.7f;
+                if (covered_height < covered_ratio * acc_rect.getHeight())
+                {
+                    // Try to show bigger portion of the content
+                    needs_to_scroll = true;
+                }
+            }
+            // else too big and in the middle of the view as is
+        }
+        if (needs_to_scroll)
         {
             // for accordition's scroll, height is in pixels
             // Back to local coords and calculate position for scroller
diff --git a/indra/llui/llscrolllistctrl.cpp b/indra/llui/llscrolllistctrl.cpp
index b459c67dad..558ce6a7fd 100644
--- a/indra/llui/llscrolllistctrl.cpp
+++ b/indra/llui/llscrolllistctrl.cpp
@@ -3185,6 +3185,7 @@ LLScrollListItem* LLScrollListCtrl::addRow(LLScrollListItem *new_item, const LLS
             if (cell_p.width.isProvided())
             {
                 new_column.width.pixel_width = cell_p.width;
+                new_column.width.pixel_width.choose();
             }
             addColumn(new_column);
             columnp = mColumns[column];
diff --git a/indra/llui/lltextbase.h b/indra/llui/lltextbase.h
index d32b8c2d0e..3ab5e905e3 100644
--- a/indra/llui/lltextbase.h
+++ b/indra/llui/lltextbase.h
@@ -259,6 +259,7 @@ public:
     /*virtual*/ void        updateLayout(const class LLTextBase& editor);
     /*virtual*/ F32         draw(S32 start, S32 end, S32 selection_start, S32 selection_end, const LLRectf& draw_rect);
     /*virtual*/ bool        canEdit() const { return false; }
+    /*virtual*/ bool        getPermitsEmoji() const { return false; }
     /*virtual*/ void        unlinkFromDocument(class LLTextBase* editor);
     /*virtual*/ void        linkToDocument(class LLTextBase* editor);
 
diff --git a/indra/llui/llurlentry.cpp b/indra/llui/llurlentry.cpp
index 95603d7ed5..bba80dd20e 100644
--- a/indra/llui/llurlentry.cpp
+++ b/indra/llui/llurlentry.cpp
@@ -234,7 +234,7 @@ bool LLUrlEntryBase::isWikiLinkCorrect(const std::string &labeled_url) const
          || label.find("www.") != std::string::npos)
         && label.find("://") == std::string::npos)
     {
-        label = "http://" + label;
+        label = "https://" + label;
     }
 
     return !LLUrlRegistry::instance().hasUrl(label);
@@ -315,7 +315,7 @@ std::string LLUrlEntryHTTP::getUrl(const std::string &string) const
 {
     if (string.find("://") == std::string::npos)
     {
-        return "http://" + escapeUrl(string);
+        return "https://" + escapeUrl(string);
     }
     return escapeUrl(string);
 }
diff --git a/indra/llwebrtc/llwebrtc.cpp b/indra/llwebrtc/llwebrtc.cpp
index 76ca4abb25..8e08239ee6 100644
--- a/indra/llwebrtc/llwebrtc.cpp
+++ b/indra/llwebrtc/llwebrtc.cpp
@@ -572,14 +572,20 @@ void LLWebRTCImpl::workerDeployDevices()
 void LLWebRTCImpl::setCaptureDevice(const std::string &id)
 {
 
-    mRecordingDevice = id;
-    deployDevices();
+    if (mRecordingDevice != id)
+    {
+        mRecordingDevice = id;
+        deployDevices();
+    }
 }
 
 void LLWebRTCImpl::setRenderDevice(const std::string &id)
 {
-    mPlayoutDevice = id;
-    deployDevices();
+    if (mPlayoutDevice != id)
+    {
+        mPlayoutDevice = id;
+        deployDevices();
+    }
 }
 
 // updateDevices needs to happen on the worker thread.
@@ -808,6 +814,7 @@ LLWebRTCPeerConnectionImpl::~LLWebRTCPeerConnectionImpl()
 {
     mSignalingObserverList.clear();
     mDataObserverList.clear();
+    mPeerConnectionFactory.release();
     if (mPendingJobs > 0)
     {
         RTC_LOG(LS_ERROR) << __FUNCTION__ << "Destroying a connection that has " << std::to_string(mPendingJobs) << " unfinished jobs that might cause workers to crash";
@@ -871,7 +878,6 @@ void LLWebRTCPeerConnectionImpl::terminate()
             }
             mPendingJobs--;
         });
-    mPeerConnectionFactory.release();
 }
 
 void LLWebRTCPeerConnectionImpl::setSignalingObserver(LLWebRTCSignalingObserver *observer) { mSignalingObserverList.emplace_back(observer); }
@@ -998,6 +1004,7 @@ bool LLWebRTCPeerConnectionImpl::initializeConnection(const LLWebRTCPeerConnecti
             }
 
             webrtc::PeerConnectionInterface::RTCOfferAnswerOptions offerOptions;
+            this->AddRef(); // CreateOffer will deref this when it's done.  Without this, the callbacks never get called.
             mPeerConnection->CreateOffer(this, offerOptions);
             mPendingJobs--;
         });
diff --git a/indra/newview/VIEWER_VERSION.txt b/indra/newview/VIEWER_VERSION.txt
index 429dc57af3..4703009f54 100644
--- a/indra/newview/VIEWER_VERSION.txt
+++ b/indra/newview/VIEWER_VERSION.txt
@@ -1 +1 @@
-7.2.3
+2026.01.0
diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml
index 3dbb5dca1f..d7df8aeb44 100644
--- a/indra/newview/app_settings/settings.xml
+++ b/indra/newview/app_settings/settings.xml
@@ -4484,13 +4484,24 @@
     <key>MainloopTimeoutDefault</key>
     <map>
       <key>Comment</key>
-      <string>Timeout duration for mainloop lock detection, in seconds.</string>
+      <string>Timeout duration for mainloop lock detection during teleports, login and logout, in seconds.</string>
       <key>Persist</key>
       <integer>1</integer>
       <key>Type</key>
       <string>F32</string>
       <key>Value</key>
-      <real>60.0</real>
+      <real>120.0</real>
+    </map>
+    <key>MainloopTimeoutStarted</key>
+    <map>
+        <key>Comment</key>
+        <string>Timeout duration for mainloop lock detection when logged in and not teleporting, in seconds.</string>
+        <key>Persist</key>
+        <integer>1</integer>
+        <key>Type</key>
+        <string>F32</string>
+        <key>Value</key>
+        <real>30.0</real>
     </map>
     <key>MapScale</key>
     <map>
@@ -7324,7 +7335,7 @@
     <key>Type</key>
     <string>F32</string>
     <key>Value</key>
-    <real>32.0</real>
+    <real>48.0</real>
   </map>
   <key>RenderCPUBasis</key>
   <map>
@@ -13862,13 +13873,13 @@
     <key>WatchdogEnabled</key>
     <map>
       <key>Comment</key>
-      <string>Controls whether the thread watchdog timer is activated. Value is boolean. Set to -1 to defer to built-in default.</string>
+      <string>Controls whether the thread watchdog timer is activated. Value is S32. Set to -1 to defer to built-in default.</string>
       <key>Persist</key>
       <integer>0</integer>
       <key>Type</key>
       <string>S32</string>
       <key>Value</key>
-      <integer>0</integer>
+      <integer>1</integer>
     </map>
     <key>WaterGLFogDensityScale</key>
     <map>
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 72bfdcf83c..b8aac829fe 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -3145,7 +3145,7 @@ bool LLAppViewer::initWindow()
 
     // Need to load feature table before cheking to start watchdog.
     bool use_watchdog = false;
-    int watchdog_enabled_setting = gSavedSettings.getS32("WatchdogEnabled");
+    S32 watchdog_enabled_setting = gSavedSettings.getS32("WatchdogEnabled");
     if (watchdog_enabled_setting == -1)
     {
         use_watchdog = !LLFeatureManager::getInstance()->isFeatureAvailable("WatchdogDisabled");
@@ -3950,7 +3950,7 @@ void LLAppViewer::processMarkerFiles()
 #if LL_WINDOWS && LL_BUGSPLAT
             // bugsplat will set correct state in bugsplatSendLog
             // Might be more accurate to rename this one into 'unknown'
-            gLastExecEvent = LAST_EXEC_FROZE;
+            gLastExecEvent = LAST_EXEC_UNKNOWN;
 #else
             gLastExecEvent = LAST_EXEC_OTHER_CRASH;
 #endif // LL_WINDOWS
@@ -3996,7 +3996,8 @@ void LLAppViewer::processMarkerFiles()
     {
         if (markerIsSameVersion(logout_marker_file))
         {
-            gLastExecEvent = LAST_EXEC_LOGOUT_FROZE;
+            // Either froze, got killed or somehow crash was not caught
+            gLastExecEvent = LAST_EXEC_LOGOUT_UNKNOWN;
             LL_INFOS("MarkerFile") << "Logout crash marker '"<< logout_marker_file << "', changing LastExecEvent to LOGOUT_FROZE" << LL_ENDL;
         }
         else
@@ -4509,7 +4510,19 @@ void LLAppViewer::purgeCacheImmediate()
 {
     LL_INFOS("AppCache") << "Purging Object Cache and Texture Cache immediately..." << LL_ENDL;
     LLAppViewer::getTextureCache()->purgeCache(LL_PATH_CACHE, false);
-    LLVOCache::getInstance()->removeCache(LL_PATH_CACHE, true);
+    if (LLVOCache::instanceExists())
+    {
+        LLVOCache::getInstance()->removeCache(LL_PATH_CACHE, true);
+    }
+    else if (!mSecondInstance)
+    {
+        // LLVOCache requires parameters to be initialized, if it's not there, try manually
+        std::string mask = "*";
+        std::string cache_dir = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "objectcache");
+        LL_INFOS() << "Removing cache at " << cache_dir << LL_ENDL;
+        gDirUtilp->deleteFilesInDir(cache_dir, mask); //delete all files
+        LLFile::rmdir(cache_dir);
+    }
 }
 
 std::string LLAppViewer::getSecondLifeTitle() const
@@ -5820,12 +5833,12 @@ void LLAppViewer::forceExceptionThreadCrash()
     thread->start();
 }
 
-void LLAppViewer::initMainloopTimeout(std::string_view state, F32 secs)
+void LLAppViewer::initMainloopTimeout(std::string_view state)
 {
     if (!mMainloopTimeout)
     {
         mMainloopTimeout = new LLWatchdogTimeout();
-        resumeMainloopTimeout(state, secs);
+        resumeMainloopTimeout(state);
     }
 }
 
@@ -5838,17 +5851,11 @@ void LLAppViewer::destroyMainloopTimeout()
     }
 }
 
-void LLAppViewer::resumeMainloopTimeout(std::string_view state, F32 secs)
+void LLAppViewer::resumeMainloopTimeout(std::string_view state)
 {
     if (mMainloopTimeout)
     {
-        if (secs < 0.0f)
-        {
-            static LLCachedControl<F32> mainloop_timeout(gSavedSettings, "MainloopTimeoutDefault", 60.f);
-            secs = mainloop_timeout;
-        }
-
-        mMainloopTimeout->setTimeout(secs);
+        mMainloopTimeout->setTimeout(getMainloopTimeoutSec());
         mMainloopTimeout->start(state);
     }
 }
@@ -5861,23 +5868,33 @@ void LLAppViewer::pauseMainloopTimeout()
     }
 }
 
-void LLAppViewer::pingMainloopTimeout(std::string_view state, F32 secs)
+void LLAppViewer::pingMainloopTimeout(std::string_view state)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_APP;
 
     if (mMainloopTimeout)
     {
-        if (secs < 0.0f)
-        {
-            static LLCachedControl<F32> mainloop_timeout(gSavedSettings, "MainloopTimeoutDefault", 60);
-            secs = mainloop_timeout;
-        }
-
-        mMainloopTimeout->setTimeout(secs);
+        mMainloopTimeout->setTimeout(getMainloopTimeoutSec());
         mMainloopTimeout->ping(state);
     }
 }
 
+
+F32 LLAppViewer::getMainloopTimeoutSec() const
+{
+    if (LLStartUp::getStartupState() == STATE_STARTED
+        && gAgent.getTeleportState() == LLAgent::TELEPORT_NONE)
+    {
+        static LLCachedControl<F32> mainloop_started(gSavedSettings, "MainloopTimeoutStarted", 30.f);
+        return mainloop_started();
+    }
+    else
+    {
+        static LLCachedControl<F32> mainloop_default(gSavedSettings, "MainloopTimeoutDefault", 120.f);
+        return mainloop_default();
+    }
+}
+
 void LLAppViewer::handleLoginComplete()
 {
     gLoggedInTime.start();
diff --git a/indra/newview/llappviewer.h b/indra/newview/llappviewer.h
index c12b2e83ef..6b0d3e0b27 100644
--- a/indra/newview/llappviewer.h
+++ b/indra/newview/llappviewer.h
@@ -77,6 +77,8 @@ typedef enum
     LAST_EXEC_BAD_ALLOC,
     LAST_EXEC_MISSING_FILES,
     LAST_EXEC_GRAPHICS_INIT,
+    LAST_EXEC_UNKNOWN,
+    LAST_EXEC_LOGOUT_UNKNOWN,
     LAST_EXEC_COUNT
 } eLastExecEvent;
 
@@ -204,11 +206,13 @@ public:
     // For thread debugging.
     // llstartup needs to control init.
     // llworld, send_agent_pause() also controls pause/resume.
-    void initMainloopTimeout(std::string_view state, F32 secs = -1.0f);
+    void initMainloopTimeout(std::string_view state);
     void destroyMainloopTimeout();
     void pauseMainloopTimeout();
-    void resumeMainloopTimeout(std::string_view state = "", F32 secs = -1.0f);
-    void pingMainloopTimeout(std::string_view state, F32 secs = -1.0f);
+    void resumeMainloopTimeout(std::string_view state = "");
+    void pingMainloopTimeout(std::string_view state);
+
+    F32 getMainloopTimeoutSec() const;
 
     // Handle the 'login completed' event.
     // *NOTE:Mani Fix this for login abstraction!!
diff --git a/indra/newview/llappviewerwin32.cpp b/indra/newview/llappviewerwin32.cpp
index a951338138..0620b625d9 100644
--- a/indra/newview/llappviewerwin32.cpp
+++ b/indra/newview/llappviewerwin32.cpp
@@ -176,10 +176,17 @@ namespace
             LLAppViewer* app = LLAppViewer::instance();
             if (!app->isSecondInstance() && !app->errorMarkerExists())
             {
-                // If marker doesn't exist, create a marker with 'other' code for next launch
+                // If marker doesn't exist, create a marker with 'other' or 'logout' code for next launch
                 // otherwise don't override existing file
                 // Any unmarked crashes will be considered as freezes
-                app->createErrorMarker(LAST_EXEC_OTHER_CRASH);
+                if (app->logoutRequestSent())
+                {
+                    app->createErrorMarker(LAST_EXEC_LOGOUT_CRASH);
+                }
+                else
+                {
+                    app->createErrorMarker(LAST_EXEC_OTHER_CRASH);
+                }
             }
         } // MDSCB_EXCEPTIONCODE
 
diff --git a/indra/newview/lldrawable.cpp b/indra/newview/lldrawable.cpp
index 322ee90541..da9378ad12 100644
--- a/indra/newview/lldrawable.cpp
+++ b/indra/newview/lldrawable.cpp
@@ -723,9 +723,13 @@ F32 LLDrawable::updateXform(bool undamped)
     mXform.setRotation(target_rot);
     mXform.setScale(LLVector3(1,1,1)); //no scale in drawable transforms (IT'S A RULE!)
     mXform.updateMatrix();
-    if (isRoot() && mVObjp->isAnimatedObject() && mVObjp->getControlAvatar())
+    if (isRoot() && mVObjp->isAnimatedObject())
     {
-        mVObjp->getControlAvatar()->matchVolumeTransform();
+        LLControlAvatar* cav = mVObjp->getControlAvatar();
+        if (cav)
+        {
+            cav->matchVolumeTransform();
+        }
     }
 
     if (mSpatialBridge)
diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 87b6ce6cb3..bc45734e66 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -278,7 +278,7 @@ void LLDrawPoolAlpha::forwardRender(bool rigged)
 
 void LLDrawPoolAlpha::renderDebugAlpha()
 {
-    if (sShowDebugAlpha)
+    if (sShowDebugAlpha && !gCubeSnapshot)
     {
         gHighlightProgram.bind();
         gGL.diffuseColor4f(1, 0, 0, 1);
diff --git a/indra/newview/lldrawpoolbump.cpp b/indra/newview/lldrawpoolbump.cpp
index 0578072bb2..6c151351ff 100644
--- a/indra/newview/lldrawpoolbump.cpp
+++ b/indra/newview/lldrawpoolbump.cpp
@@ -798,7 +798,10 @@ void LLBumpImageList::onSourceStandardLoaded( bool success, LLViewerFetchedTextu
         }
         src_vi->setExplicitFormat(GL_RGBA, GL_RGBA);
         {
-            src_vi->createGLTexture(src_vi->getDiscardLevel(), nrm_image);
+            if (!src_vi->createGLTexture(src_vi->getDiscardLevel(), nrm_image))
+            {
+                LL_WARNS() << "Failed to create bump image texture for image " << src_vi->getID() << LL_ENDL;
+            }
         }
     }
 }
@@ -892,7 +895,10 @@ void LLBumpImageList::onSourceUpdated(LLViewerTexture* src, EBumpEffect bump_cod
 
         LLImageGL* src_img = src->getGLTexture();
         LLImageGL* dst_img = bump->getGLTexture();
-        dst_img->setSize(src->getWidth(), src->getHeight(), 4, 0);
+        if (!dst_img->setSize(src->getWidth(), src->getHeight(), 4, 0))
+        {
+            LL_WARNS() << "Failed to setSize for image " << bump->getID() << LL_ENDL;
+        }
         dst_img->setUseMipMaps(true);
         dst_img->setDiscardLevel(0);
         dst_img->createGLTexture();
diff --git a/indra/newview/llfeaturemanager.cpp b/indra/newview/llfeaturemanager.cpp
index 1bffe34b8f..e9bee93a19 100644
--- a/indra/newview/llfeaturemanager.cpp
+++ b/indra/newview/llfeaturemanager.cpp
@@ -403,8 +403,53 @@ F32 logExceptionBenchmark()
 }
 #endif
 
+bool checkRDNA35()
+{
+    // This checks if we're running on an RDNA3.5 GPU.  You're only going to see these on AMD's APUs.
+    // As of driver version 25, we're seeing stalls in some of our queries.
+    // This appears to be a driver bug, and appears to be specific RDNA3.5 APUs.
+    // There's multiples of these guys, so we just use this function to check if that GPU is on the list of known RDNA3.5 APUs.
+    // - Geenz 11/12/2025
+    std::array<std::string, 7> rdna35GPUs = {
+        "8060S",
+        "8050S",
+        "8040S",
+        "860M",
+        "840M",
+        "890M",
+        "880M"
+    };
+
+    for (const auto& gpu_name : rdna35GPUs)
+    {
+        if (gGLManager.getRawGLString().find(gpu_name) != std::string::npos)
+        {
+            LL_WARNS("RenderInit") << "Detected AMD RDNA3.5 GPU (" << gpu_name << ")." << LL_ENDL;
+            return true;
+        }
+    }
+
+    return false;
+}
+
 bool LLFeatureManager::loadGPUClass()
 {
+    // This is a hack for certain AMD GPUs in newer driver versions on certain APUs.
+    // These GPUs will show inconsistent freezes when attempting to run shader profiles against them.
+    // This is extremely problematic as it can lead to:
+    // - Login freezes
+    // - Inability to start the client
+    // - Completely random avatars triggering a freeze
+    // As a result, we filter out these GPUs for shader profiling.
+    // - Geenz 11/11/2025
+
+    if (gGLManager.getRawGLString().find("Radeon") != std::string::npos && checkRDNA35() && gGLManager.mDriverVersionVendorString.find("25.") != std::string::npos)
+    {
+        LL_WARNS("RenderInit") << "Detected AMD RDNA3.5 GPU on a known bad driver; disabling benchmark and occlusion culling to prevent freezes." << LL_ENDL;
+        gSavedSettings.setBOOL("SkipBenchmark", true);
+        gSavedSettings.setBOOL("UseOcclusion", false);
+    }
+
     if (!gSavedSettings.getBOOL("SkipBenchmark"))
     {
         F32 class1_gbps = gSavedSettings.getF32("RenderClass1MemoryBandwidth");
@@ -464,7 +509,7 @@ bool LLFeatureManager::loadGPUClass()
         }
 
     #if LL_WINDOWS
-        const F32Gigabytes MIN_PHYSICAL_MEMORY(2);
+        const F32Gigabytes MIN_PHYSICAL_MEMORY(8);
 
         LLMemory::updateMemoryInfo();
         F32Gigabytes physical_mem = LLMemory::getMaxMemKB();
diff --git a/indra/newview/llfeaturemanager.h b/indra/newview/llfeaturemanager.h
index 22de6afbae..d04b89cb60 100644
--- a/indra/newview/llfeaturemanager.h
+++ b/indra/newview/llfeaturemanager.h
@@ -123,6 +123,7 @@ public:
     S32 getVersion() const              { return mTableVersion; }
     void setSafe(const bool safe)       { mSafe = safe; }
     bool isSafe() const                 { return mSafe; }
+    bool skipProfiling() const          { return mSkipProfiling; }
 
     LLFeatureList *findMask(const std::string& name);
     bool maskFeatures(const std::string& name);
@@ -170,6 +171,7 @@ protected:
     F32         mExpectedGLVersion;     //expected GL version according to gpu table
     std::string mGPUString;
     bool        mGPUSupported;
+    bool        mSkipProfiling = false;
 };
 
 inline
diff --git a/indra/newview/llfilepicker_mac.h b/indra/newview/llfilepicker_mac.h
index f0e9ce81dc..d0374c5a08 100644
--- a/indra/newview/llfilepicker_mac.h
+++ b/indra/newview/llfilepicker_mac.h
@@ -44,7 +44,7 @@ std::unique_ptr<std::vector<std::string>> doLoadDialog(const std::vector<std::st
 
 // doLoadDialogModeless if window does not exists creates a modeless
 // window, if it does exist, creates a 'sheet' that does not block
-// thead but blocks window interractions
+// thread but blocks window interractions
 void doLoadDialogModeless(const std::vector<std::string>* allowed_types,
                 unsigned int flags,
                 void (*callback)(bool, std::vector<std::string>&, void*),
diff --git a/indra/newview/llfloater360capture.cpp b/indra/newview/llfloater360capture.cpp
index 25970f8a08..95e7b9af41 100644
--- a/indra/newview/llfloater360capture.cpp
+++ b/indra/newview/llfloater360capture.cpp
@@ -716,7 +716,7 @@ void LLFloater360Capture::onSaveLocalBtn()
 {
     // region name and URL
     std::string region_name; // no sensible default
-    std::string region_url("http://secondlife.com");
+    std::string region_url("https://secondlife.com");
     LLViewerRegion* region = gAgent.getRegion();
     if (region)
     {
diff --git a/indra/newview/llfloateravatarwelcomepack.cpp b/indra/newview/llfloateravatarwelcomepack.cpp
index 82e44d1398..be384bf4d1 100644
--- a/indra/newview/llfloateravatarwelcomepack.cpp
+++ b/indra/newview/llfloateravatarwelcomepack.cpp
@@ -28,8 +28,10 @@
 #include "llviewerprecompiledheaders.h"
 
 #include "llfloateravatarwelcomepack.h"
-#include "lluictrlfactory.h"
 #include "llmediactrl.h"
+#include "lluictrlfactory.h"
+#include "llviewercontrol.h"
+#include "llweb.h"
 
 LLFloaterAvatarWelcomePack::LLFloaterAvatarWelcomePack(const LLSD& key)
     :   LLFloater(key)
@@ -52,6 +54,10 @@ bool LLFloaterAvatarWelcomePack::postBuild()
     if (mAvatarPicker)
     {
         mAvatarPicker->clearCache();
+        mAvatarPicker->setErrorPageURL(gSavedSettings.getString("GenericErrorPageURL"));
+        std::string url = gSavedSettings.getString("AvatarWelcomePack");
+        url = LLWeb::expandURLSubstitutions(url, LLSD());
+        mAvatarPicker->navigateTo(url, HTTP_CONTENT_TEXT_HTML);
     }
 
     return true;
diff --git a/indra/newview/llfloaterdestinations.cpp b/indra/newview/llfloaterdestinations.cpp
index fad9693e8f..84fc4afcdd 100644
--- a/indra/newview/llfloaterdestinations.cpp
+++ b/indra/newview/llfloaterdestinations.cpp
@@ -28,7 +28,10 @@
 #include "llviewerprecompiledheaders.h"
 
 #include "llfloaterdestinations.h"
+#include "llmediactrl.h"
 #include "lluictrlfactory.h"
+#include "llviewercontrol.h"
+#include "llweb.h"
 
 
 LLFloaterDestinations::LLFloaterDestinations(const LLSD& key)
@@ -43,6 +46,15 @@ LLFloaterDestinations::~LLFloaterDestinations()
 bool LLFloaterDestinations::postBuild()
 {
     enableResizeCtrls(true, true, false);
+    LLMediaCtrl* destinations = getChild<LLMediaCtrl>("destination_guide_contents");
+    destinations->setErrorPageURL(gSavedSettings.getString("GenericErrorPageURL"));
+    std::string url = gSavedSettings.getString("DestinationGuideURL");
+    url = LLWeb::expandURLSubstitutions(url, LLSD());
+    destinations->navigateTo(url, HTTP_CONTENT_TEXT_HTML);
+
+    // If cookie is there, will set it now. Otherwise will have to wait for login completion
+    // which will also update destinations instance if it already exists.
+    LLViewerMedia::getInstance()->getOpenIDCookie(destinations);
     return true;
 }
 
diff --git a/indra/newview/llfloatermarketplace.cpp b/indra/newview/llfloatermarketplace.cpp
index 4abea64302..7316d7617d 100644
--- a/indra/newview/llfloatermarketplace.cpp
+++ b/indra/newview/llfloatermarketplace.cpp
@@ -46,9 +46,16 @@ void LLFloaterMarketplace::onClose(bool app_quitting)
 
 bool LLFloaterMarketplace::postBuild()
 {
-    LLFloaterWebContent::postBuild();
-    mWebBrowser = getChild<LLMediaCtrl>("marketplace_contents");
-    mWebBrowser->addObserver(this);
+    if (!LLFloaterWebContent::postBuild())
+        return false;
+
+    mWebBrowser->setErrorPageURL(gSavedSettings.getString("GenericErrorPageURL"));
+    std::string url = gSavedSettings.getString("MarketplaceURL");
+    mWebBrowser->navigateTo(url, HTTP_CONTENT_TEXT_HTML);
+
+    // If cookie is there, will set it now, Otherwise will have to wait for login completion
+    // which will also update marketplace instance if it already exists.
+    LLViewerMedia::getInstance()->getOpenIDCookie(mWebBrowser);
 
     return true;
 }
diff --git a/indra/newview/llfloaterobjectweights.cpp b/indra/newview/llfloaterobjectweights.cpp
index fa491a4b27..bd8530abd7 100644
--- a/indra/newview/llfloaterobjectweights.cpp
+++ b/indra/newview/llfloaterobjectweights.cpp
@@ -208,7 +208,7 @@ void LLFloaterObjectWeights::draw()
             toggleRenderLoadingIndicators(false);
         }
         mTrianglesShown->setText(llformat("%d", total_tris));
-        mPixelArea->setText(llformat("%d", pixel_area));
+        mPixelArea->setText(llformat("%ld", (S64)pixel_area)); // value capped at 10M
     }
     LLFloater::draw();
 }
diff --git a/indra/newview/llfloaterregioninfo.cpp b/indra/newview/llfloaterregioninfo.cpp
index bfce13affc..4cb6e7be96 100644
--- a/indra/newview/llfloaterregioninfo.cpp
+++ b/indra/newview/llfloaterregioninfo.cpp
@@ -269,10 +269,12 @@ bool LLFloaterRegionInfo::postBuild()
     static LLCachedControl<bool> feature_pbr_terrain_transforms_enabled(gSavedSettings, "RenderTerrainPBRTransformsEnabled", false);
     if (!feature_pbr_terrain_transforms_enabled() || !feature_pbr_terrain_enabled())
     {
+        LL_INFOS("Terrain") << "Building region terrain panel from panel_region_terrain.xml" << LL_ENDL;
         panel->buildFromFile("panel_region_terrain.xml");
     }
     else
     {
+        LL_INFOS("Terrain") << "Building region terrain panel from panel_region_terrain_texture_transform.xml" << LL_ENDL;
         panel->buildFromFile("panel_region_terrain_texture_transform.xml");
     }
     mTab->addTabPanel(panel);
@@ -1489,6 +1491,11 @@ bool LLPanelRegionTerrainInfo::validateMaterials()
         const LLUUID& material_asset_id = material_ctrl->getImageAssetID();
         llassert(material_asset_id.notNull());
         if (material_asset_id.isNull()) { return false; }
+        if (material_asset_id == BLANK_MATERIAL_ASSET_ID)
+        {
+            // Default/Blank material is valid by default
+            continue;
+        }
         const LLFetchedGLTFMaterial* material = gGLTFMaterialList.getMaterial(material_asset_id);
         if (!material->isLoaded())
         {
@@ -1998,18 +2005,7 @@ void LLPanelRegionTerrainInfo::initMaterialCtrl(LLTextureCtrl*& ctrl, const std:
     ctrl->setCommitCallback(
         [this, index](LLUICtrl* ctrl, const LLSD& param)
     {
-        if (!mMaterialScaleUCtrl[index]
-            || !mMaterialScaleVCtrl[index]
-            || !mMaterialRotationCtrl[index]
-            || !mMaterialOffsetUCtrl[index]
-            || !mMaterialOffsetVCtrl[index]) return;
-
-        mMaterialScaleUCtrl[index]->setValue(1.f);
-        mMaterialScaleVCtrl[index]->setValue(1.f);
-        mMaterialRotationCtrl[index]->setValue(0.f);
-        mMaterialOffsetUCtrl[index]->setValue(0.f);
-        mMaterialOffsetVCtrl[index]->setValue(0.f);
-        onChangeAnything();
+        callbackMaterialCommit(index);
     });
 }
 
@@ -2097,6 +2093,25 @@ bool LLPanelRegionTerrainInfo::callbackBakeTerrain(const LLSD& notification, con
     return false;
 }
 
+void LLPanelRegionTerrainInfo::callbackMaterialCommit(S32 index)
+{
+    // These can be null if 'transforms' panel was not inited
+    if (mMaterialScaleUCtrl[index]
+        && mMaterialScaleVCtrl[index]
+        && mMaterialRotationCtrl[index]
+        && mMaterialOffsetUCtrl[index]
+        && mMaterialOffsetVCtrl[index])
+    {
+        mMaterialScaleUCtrl[index]->setValue(1.f);
+        mMaterialScaleVCtrl[index]->setValue(1.f);
+        mMaterialRotationCtrl[index]->setValue(0.f);
+        mMaterialOffsetUCtrl[index]->setValue(0.f);
+        mMaterialOffsetVCtrl[index]->setValue(0.f);
+    }
+
+    onChangeAnything();
+}
+
 /////////////////////////////////////////////////////////////////////////////
 // LLPanelEstateInfo
 //
diff --git a/indra/newview/llfloaterregioninfo.h b/indra/newview/llfloaterregioninfo.h
index a8631c36ca..0036df9c3d 100644
--- a/indra/newview/llfloaterregioninfo.h
+++ b/indra/newview/llfloaterregioninfo.h
@@ -272,6 +272,7 @@ public:
     static void onClickBakeTerrain(void*);
     bool callbackBakeTerrain(const LLSD& notification, const LLSD& response);
     bool callbackTextureHeights(const LLSD& notification, const LLSD& response);
+    void callbackMaterialCommit(S32 index);
 
 protected:
     bool sendUpdate() override;
diff --git a/indra/newview/llfloatersearch.cpp b/indra/newview/llfloatersearch.cpp
index 7ee1b88f05..9b7a4e5134 100644
--- a/indra/newview/llfloatersearch.cpp
+++ b/indra/newview/llfloatersearch.cpp
@@ -161,15 +161,20 @@ void LLFloaterSearch::initiateSearch(const LLSD& tokens)
 
     // Naviation to the calculated URL - we know it's HTML so we can
     // tell the media system not to bother with the MIME type check.
-    LLMediaCtrl* search_browser = findChild<LLMediaCtrl>("search_contents");
-    search_browser->navigateTo(url, HTTP_CONTENT_TEXT_HTML);
+    mWebBrowser->navigateTo(url, HTTP_CONTENT_TEXT_HTML);
 }
 
 bool LLFloaterSearch::postBuild()
 {
-    LLFloaterWebContent::postBuild();
-    mWebBrowser = getChild<LLMediaCtrl>("search_contents");
-    mWebBrowser->addObserver(this);
+    if (!LLFloaterWebContent::postBuild())
+        return false;
+
+    mWebBrowser->setErrorPageURL(gSavedSettings.getString("GenericErrorPageURL"));
+
+    // If cookie is there, will set it now, Otherwise will have to wait for login completion
+    // which will also update search instance if it already exists.
+    LLViewerMedia::getInstance()->getOpenIDCookie(mWebBrowser);
+
     getChildView("address")->setEnabled(false);
     getChildView("popexternal")->setEnabled(false);
 
diff --git a/indra/newview/llglsandbox.cpp b/indra/newview/llglsandbox.cpp
index 112008172e..5484ce6276 100644
--- a/indra/newview/llglsandbox.cpp
+++ b/indra/newview/llglsandbox.cpp
@@ -903,6 +903,39 @@ private:
 };
 
 
+F32 shader_timer_benchmark(std::vector<LLRenderTarget> & dest, TextureHolder & texHolder, U32 textures_count, LLVertexBuffer * buff, F32 &seconds)
+{
+    // run GPU timer benchmark
+
+    //number of samples to take
+    const S32 samples = 64;
+
+    {
+        ShaderProfileHelper initProfile;
+        dest[0].bindTarget();
+        gBenchmarkProgram.bind();
+        for (S32 c = 0; c < samples; ++c)
+        {
+            for (U32 i = 0; i < textures_count; ++i)
+            {
+                texHolder.bind(i);
+                buff->setBuffer();
+                buff->drawArrays(LLRender::TRIANGLES, 0, 3);
+            }
+        }
+        gBenchmarkProgram.unbind();
+        dest[0].flush();
+    }
+
+    F32 ms = gBenchmarkProgram.mTimeElapsed / 1000000.f;
+    seconds = ms / 1000.f;
+
+    F64 samples_drawn = (F64)gBenchmarkProgram.mSamplesDrawn;
+    F64 gpixels_drawn = samples_drawn / 1000000000.0;
+    F32 samples_sec = (F32)(gpixels_drawn / seconds);
+    return samples_sec * 4;  // 4 bytes per sample
+}
+
 //-----------------------------------------------------------------------------
 // gpu_benchmark()
 //  returns measured memory bandwidth of GPU in gigabytes per second
@@ -944,9 +977,6 @@ F32 gpu_benchmark()
     //number of textures
     const U32 count = 32;
 
-    //number of samples to take
-    const S32 samples = 64;
-
     //time limit, allocation operations shouldn't take longer then 30 seconds, same for actual benchmark.
     const F32 time_limit = 30;
 
@@ -1036,33 +1066,15 @@ F32 gpu_benchmark()
 
     LLGLSLShader::unbind();
 
-    // run GPU timer benchmark
-    {
-        ShaderProfileHelper initProfile;
-        dest[0].bindTarget();
-        gBenchmarkProgram.bind();
-        for (S32 c = 0; c < samples; ++c)
-        {
-            for (U32 i = 0; i < count; ++i)
-            {
-                texHolder.bind(i);
-                buff->setBuffer();
-                buff->drawArrays(LLRender::TRIANGLES, 0, 3);
-            }
-        }
-        gBenchmarkProgram.unbind();
-        dest[0].flush();
-    }
+    // run GPU timer benchmark twice
+    F32 seconds = 0;
+    F32 gbps = shader_timer_benchmark(dest, texHolder, count, buff.get(), seconds);
 
-    F32 ms = gBenchmarkProgram.mTimeElapsed/1000000.f;
-    F32 seconds = ms/1000.f;
+    LL_INFOS("Benchmark") << "Memory bandwidth, 1st run is " << llformat("%.3f", gbps) << " GB/sec according to ARB_timer_query, total time " << seconds << " seconds" << LL_ENDL;
 
-    F64 samples_drawn = (F64)gBenchmarkProgram.mSamplesDrawn;
-    F64 gpixels_drawn = samples_drawn / 1000000000.0;
-    F32 samples_sec = (F32)(gpixels_drawn/seconds);
-    F32 gbps = samples_sec*4;  // 4 bytes per sample
+    gbps = shader_timer_benchmark(dest, texHolder, count, buff.get(), seconds);
 
-    LL_INFOS("Benchmark") << "Memory bandwidth is " << llformat("%.3f", gbps) << " GB/sec according to ARB_timer_query, total time " << seconds << " seconds" << LL_ENDL;
+    LL_INFOS("Benchmark") << "Memory bandwidth, final run is " << llformat("%.3f", gbps) << " GB/sec according to ARB_timer_query, total time " << seconds << " seconds" << LL_ENDL;
 
     return gbps;
 }
diff --git a/indra/newview/llgrouplist.cpp b/indra/newview/llgrouplist.cpp
index 7659e5f082..074cda1683 100644
--- a/indra/newview/llgrouplist.cpp
+++ b/indra/newview/llgrouplist.cpp
@@ -317,7 +317,7 @@ void LLGroupList::addNewItem(const LLUUID& id, const std::string& name, const LL
 // virtual
 bool LLGroupList::handleEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata)
 {
-    // Why is "new group" sufficient?
+    // "new group" is sufficient because update_group_floaters always calls that on group changes
     if (event->desc() == "new group")
     {
         setDirty();
diff --git a/indra/newview/llhudnametag.cpp b/indra/newview/llhudnametag.cpp
index 11f049564a..4327d281e5 100644
--- a/indra/newview/llhudnametag.cpp
+++ b/indra/newview/llhudnametag.cpp
@@ -301,7 +301,7 @@ void LLHUDNameTag::renderText()
         const S32 label_height = ll_round((mFontp->getLineHeight() * (F32)mLabelSegments.size() + (VERTICAL_PADDING / 3.f)));
         label_top_rect.mBottom = label_top_rect.mTop - label_height;
         LLColor4 label_top_color = text_color;
-        label_top_color.mV[VALPHA] = gSavedSettings.getF32("ChatBubbleOpacity") * alpha_factor;
+        label_top_color.mV[VALPHA] = bubble_opacity() * alpha_factor;
 
         mRoundedRectTopImgp->draw3D(render_position, x_pixel_vec, y_pixel_vec, label_top_rect, label_top_color);
     }
diff --git a/indra/newview/llimprocessing.cpp b/indra/newview/llimprocessing.cpp
index fe567ac7ec..779ed725ac 100644
--- a/indra/newview/llimprocessing.cpp
+++ b/indra/newview/llimprocessing.cpp
@@ -202,9 +202,19 @@ void inventory_offer_handler(LLOfferInfo* info)
     auto indx = msg.find(" ( http://slurl.com/secondlife/");
     if (indx == std::string::npos)
     {
-        // try to find new slurl host
+        // https
+        indx = msg.find(" ( https://slurl.com/secondlife/");
+    }
+    if (indx == std::string::npos)
+    {
+        // try to find new slurl http host
         indx = msg.find(" ( http://maps.secondlife.com/secondlife/");
     }
+    if (indx == std::string::npos)
+    {
+        // try to find new slurl https host
+        indx = msg.find(" ( https://maps.secondlife.com/secondlife/");
+    }
     if (indx >= 0)
     {
         LLStringUtil::truncate(msg, indx);
diff --git a/indra/newview/llinventorypanel.cpp b/indra/newview/llinventorypanel.cpp
index cde87ede9b..8d57a4e7bb 100644
--- a/indra/newview/llinventorypanel.cpp
+++ b/indra/newview/llinventorypanel.cpp
@@ -1849,6 +1849,7 @@ void LLInventoryPanel::purgeSelectedItems()
 {
     if (!mFolderRoot.get()) return;
 
+    const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
     const std::set<LLFolderViewItem*> inventory_selected = mFolderRoot.get()->getSelectionList();
     if (inventory_selected.empty()) return;
     LLSD args;
@@ -1858,12 +1859,17 @@ void LLInventoryPanel::purgeSelectedItems()
         it != end_it;
         ++it)
     {
+        // Selection allows items outside trash folder, only count the ones inside.
         LLUUID item_id = static_cast<LLFolderViewModelItemInventory*>((*it)->getViewModelItem())->getUUID();
-        LLInventoryModel::cat_array_t cats;
-        LLInventoryModel::item_array_t items;
-        gInventory.collectDescendents(item_id, cats, items, LLInventoryModel::INCLUDE_TRASH);
-        count += items.size() + cats.size();
-        selected_items.push_back(item_id);
+        LLInventoryObject* obj = gInventory.getObject(item_id);
+        if (obj->getParentUUID() == trash_id)
+        {
+            LLInventoryModel::cat_array_t cats;
+            LLInventoryModel::item_array_t items;
+            gInventory.collectDescendents(item_id, cats, items, LLInventoryModel::INCLUDE_TRASH);
+            count += items.size() + cats.size();
+            selected_items.push_back(item_id);
+        }
     }
     args["COUNT"] = static_cast<S32>(count);
     LLNotificationsUtil::add("PurgeSelectedItems", args, LLSD(), boost::bind(callbackPurgeSelectedItems, _1, _2, selected_items));
diff --git a/indra/newview/lllocalbitmaps.cpp b/indra/newview/lllocalbitmaps.cpp
index a99c9df0ff..6e56aac270 100644
--- a/indra/newview/lllocalbitmaps.cpp
+++ b/indra/newview/lllocalbitmaps.cpp
@@ -219,7 +219,10 @@ bool LLLocalBitmap::updateSelf(EUpdateType optional_firstupdate)
                     LLPointer<LLViewerFetchedTexture> texture = new LLViewerFetchedTexture
                         ("file://"+mFilename, FTT_LOCAL_FILE, mWorldID, LL_LOCAL_USE_MIPMAPS);
 
-                    texture->createGLTexture(LL_LOCAL_DISCARD_LEVEL, raw_image);
+                    if (!texture->createGLTexture(LL_LOCAL_DISCARD_LEVEL, raw_image))
+                    {
+                        LL_WARNS() << "Failed to create GL texture for local bitmap: " << mFilename << " " << mWorldID << LL_ENDL;
+                    }
                     texture->ref();
 
                     gTextureList.addImage(texture, TEX_LIST_STANDARD);
diff --git a/indra/newview/llpanelgroup.cpp b/indra/newview/llpanelgroup.cpp
index ecb66f9cea..ad65293b98 100644
--- a/indra/newview/llpanelgroup.cpp
+++ b/indra/newview/llpanelgroup.cpp
@@ -191,6 +191,13 @@ bool LLPanelGroup::postBuild()
         mButtonJoin->setCommitCallback(boost::bind(&LLPanelGroup::onBtnJoin,this));
 
         mJoinText = panel_general->getChild<LLUICtrl>("join_cost_text");
+
+        mButtonActivate = panel_general->getChild<LLButton>("btn_activate");
+        mButtonActivate->setVisible(false);
+        mButtonActivate->setEnabled(gAgent.getGroupID() != mID);
+        mButtonActivate->setCommitCallback(boost::bind(&LLPanelGroup::onBtnActivate, this));
+
+        gAgent.addListener(this, "new group");
     }
 
     LLVoiceClient::addObserver(this);
@@ -267,6 +274,7 @@ void LLPanelGroup::onBtnJoin()
     if (LLGroupActions::isInGroup(mID))
     {
         LLGroupActions::leave(mID);
+        mButtonActivate->setVisible(false);
     }
     else
     {
@@ -275,6 +283,12 @@ void LLPanelGroup::onBtnJoin()
     }
 }
 
+void LLPanelGroup::onBtnActivate()
+{
+    LLGroupActions::activate(mID);
+    mButtonActivate->setEnabled(false);
+}
+
 void LLPanelGroup::changed(LLGroupChange gc)
 {
     for(std::vector<LLPanelGroupTab* >::iterator it = mTabs.begin();it!=mTabs.end();++it)
@@ -312,6 +326,8 @@ void LLPanelGroup::update(LLGroupChange gc)
         bool join_btn_visible = is_member || gdatap->mOpenEnrollment;
 
         mButtonJoin->setVisible(join_btn_visible);
+        mButtonActivate->setEnabled(gAgent.getGroupID() != mID);
+        mButtonActivate->setVisible(is_member);
         mJoinText->setVisible(join_btn_visible);
 
         if (is_member)
@@ -384,6 +400,8 @@ void LLPanelGroup::setGroupID(const LLUUID& group_id)
 
     if(mButtonJoin)
         mButtonJoin->setVisible(false);
+    if (mButtonActivate)
+        mButtonActivate->setVisible(false);
 
 
     if(is_null_group_id)//creating new group
@@ -598,4 +616,20 @@ void LLPanelGroup::showNotice(const std::string& subject,
 
 }
 
+bool LLPanelGroup::handleEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata)
+{
+    if (event->desc() == "new group")
+    {
+        mButtonActivate->setEnabled(gAgent.getGroupID() != mID);
+        return true;
+    }
+
+    if (event->desc() == "value_changed")
+    {
+        mButtonActivate->setEnabled(gAgent.getGroupID() != mID);
+        return true;
+    }
+
+    return false;
+}
 
diff --git a/indra/newview/llpanelgroup.h b/indra/newview/llpanelgroup.h
index b43a93bc40..d3550264a0 100644
--- a/indra/newview/llpanelgroup.h
+++ b/indra/newview/llpanelgroup.h
@@ -26,6 +26,7 @@
 #ifndef LL_LLPANELGROUP_H
 #define LL_LLPANELGROUP_H
 
+#include "llevent.h"
 #include "llgroupmgr.h"
 #include "llpanel.h"
 #include "lltimer.h"
@@ -44,7 +45,8 @@ class LLAgent;
 
 class LLPanelGroup : public LLPanel,
                      public LLGroupMgrObserver,
-                     public LLVoiceClientStatusObserver
+                     public LLVoiceClientStatusObserver,
+                     public LLOldEvents::LLSimpleListener
 {
 public:
     LLPanelGroup();
@@ -94,6 +96,7 @@ protected:
 
     void onBackBtnClick();
     void onBtnJoin();
+    void onBtnActivate();
 
     static void onBtnApply(void*);
     static void onBtnRefresh(void*);
@@ -120,11 +123,15 @@ protected:
 
     LLUICtrl*       mGroupNameCtrl = nullptr;
     LLButton*       mButtonJoin = nullptr;
+    LLButton*       mButtonActivate = nullptr;
     LLButton*       mButtonApply = nullptr;
     LLButton*       mButtonCall = nullptr;
     LLButton*       mButtonChat = nullptr;
     LLButton*       mButtonRefresh = nullptr;
     LLUICtrl*       mJoinText;
+
+private:
+    bool handleEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata); // for agent group list changes
 };
 
 class LLPanelGroupTab : public LLPanel
diff --git a/indra/newview/llpanelmediasettingssecurity.cpp b/indra/newview/llpanelmediasettingssecurity.cpp
index 6e4e9f426d..68e2808a83 100644
--- a/indra/newview/llpanelmediasettingssecurity.cpp
+++ b/indra/newview/llpanelmediasettingssecurity.cpp
@@ -220,7 +220,7 @@ const std::string LLPanelMediaSettingsSecurity::makeValidUrl( const std::string&
     if ( candidate_url.scheme().empty() )
     {
         // build a URL comprised of default scheme and the original fragment
-        const std::string default_scheme( "http://" );
+        const std::string default_scheme( "https://" );
         return default_scheme + src_url;
     };
 
diff --git a/indra/newview/llurllineeditorctrl.cpp b/indra/newview/llurllineeditorctrl.cpp
index de0ed645eb..871bf36ed3 100644
--- a/indra/newview/llurllineeditorctrl.cpp
+++ b/indra/newview/llurllineeditorctrl.cpp
@@ -84,7 +84,9 @@ void LLURLLineEditor::copyEscapedURLToClipboard()
     const std::string unescaped_text = wstring_to_utf8str(mText.getWString().substr(left_pos, length));
     LLWString text_to_copy;
     // *HACK: Because LLSLURL is currently broken we cannot use it to check if unescaped_text is a valid SLURL (see EXT-8335).
-    if (LLStringUtil::startsWith(unescaped_text, "http://") || LLStringUtil::startsWith(unescaped_text, "secondlife://")) // SLURL
+    if (LLStringUtil::startsWith(unescaped_text, "https://")
+        || LLStringUtil::startsWith(unescaped_text, "http://")
+        || LLStringUtil::startsWith(unescaped_text, "secondlife://")) // SLURL
         text_to_copy = utf8str_to_wstring(LLWeb::escapeURL(unescaped_text));
     else // human-readable location
         text_to_copy = utf8str_to_wstring(unescaped_text);
diff --git a/indra/newview/llvieweraudio.cpp b/indra/newview/llvieweraudio.cpp
index aa0cbac91f..a7441febd9 100644
--- a/indra/newview/llvieweraudio.cpp
+++ b/indra/newview/llvieweraudio.cpp
@@ -398,18 +398,12 @@ void init_audio()
 
 void audio_update_volume(bool force_update)
 {
-    F32 master_volume = gSavedSettings.getF32("AudioLevelMaster");
-    bool mute_audio = gSavedSettings.getBOOL("MuteAudio");
-
-    LLProgressView* progress = gViewerWindow->getProgressView();
-    bool progress_view_visible = false;
-
-    if (progress)
-    {
-        progress_view_visible = progress->getVisible();
-    }
+    static LLCachedControl<F32> master_volume(gSavedSettings, "AudioLevelMaster");
+    static LLCachedControl<bool> mute_audio_setting(gSavedSettings, "MuteAudio");
+    static LLCachedControl<bool> mute_when_minimized(gSavedSettings, "MuteWhenMinimized");
+    bool mute_audio = mute_audio_setting();
 
-    if (!gViewerWindow->getActive() && gSavedSettings.getBOOL("MuteWhenMinimized"))
+    if (!gViewerWindow->getActive() && mute_when_minimized())
     {
         mute_audio = true;
     }
@@ -419,7 +413,7 @@ void audio_update_volume(bool force_update)
     {
         // Sound Effects
 
-        gAudiop->setMasterGain ( master_volume );
+        gAudiop->setMasterGain (master_volume());
 
         const F32 AUDIO_LEVEL_DOPPLER = 1.f;
         gAudiop->setDopplerFactor(AUDIO_LEVEL_DOPPLER);
@@ -435,6 +429,7 @@ void audio_update_volume(bool force_update)
             gAudiop->setRolloffFactor(AUDIO_LEVEL_UNDERWATER_ROLLOFF);
         }
 
+        bool progress_view_visible = gViewerWindow->getShowProgress();
         gAudiop->setMuted(mute_audio || progress_view_visible);
 
         //Play any deferred sounds when unmuted
@@ -448,13 +443,21 @@ void audio_update_volume(bool force_update)
             audio_update_wind(true);
         }
 
+        static LLCachedControl<bool> mute_sounds(gSavedSettings, "MuteSounds");
+        static LLCachedControl<bool> mute_ui(gSavedSettings, "MuteUI");
+        static LLCachedControl<bool> mute_ambient(gSavedSettings, "MuteAmbient");
+        static LLCachedControl<bool> mute_music(gSavedSettings, "MuteMusic");
+        static LLCachedControl<F32> al_sfx(gSavedSettings, "AudioLevelSFX");
+        static LLCachedControl<F32> al_ui(gSavedSettings, "AudioLevelUI");
+        static LLCachedControl<F32> al_ambient(gSavedSettings, "AudioLevelAmbient");
+        static LLCachedControl<F32> al_music(gSavedSettings, "AudioLevelMusic");
         // handle secondary gains
         gAudiop->setSecondaryGain(LLAudioEngine::AUDIO_TYPE_SFX,
-                                  gSavedSettings.getBOOL("MuteSounds") ? 0.f : gSavedSettings.getF32("AudioLevelSFX"));
+                                  mute_sounds() ? 0.f : al_sfx());
         gAudiop->setSecondaryGain(LLAudioEngine::AUDIO_TYPE_UI,
-                                  gSavedSettings.getBOOL("MuteUI") ? 0.f : gSavedSettings.getF32("AudioLevelUI"));
+                                  mute_ui() ? 0.f : al_ui());
         gAudiop->setSecondaryGain(LLAudioEngine::AUDIO_TYPE_AMBIENT,
-                                  gSavedSettings.getBOOL("MuteAmbient") ? 0.f : gSavedSettings.getF32("AudioLevelAmbient"));
+                                  mute_ambient() ? 0.f : al_ambient());
 
         // Streaming Music
 
@@ -464,31 +467,29 @@ void audio_update_volume(bool force_update)
             LLViewerAudio::getInstance()->setForcedTeleportFade(false);
         }
 
-        F32 music_volume = gSavedSettings.getF32("AudioLevelMusic");
-        bool music_muted = gSavedSettings.getBOOL("MuteMusic");
         F32 fade_volume = LLViewerAudio::getInstance()->getFadeVolume();
 
-        music_volume = mute_volume * master_volume * music_volume * fade_volume;
-        gAudiop->setInternetStreamGain (music_muted ? 0.f : music_volume);
+        F32 music_volume = mute_volume * master_volume * al_music() * fade_volume;
+        gAudiop->setInternetStreamGain (mute_music() ? 0.f : music_volume);
     }
 
     // Streaming Media
-    F32 media_volume = gSavedSettings.getF32("AudioLevelMedia");
-    bool media_muted = gSavedSettings.getBOOL("MuteMedia");
-    media_volume = mute_volume * master_volume * media_volume;
-    LLViewerMedia::getInstance()->setVolume( media_muted ? 0.0f : media_volume );
+    static LLCachedControl<bool> media_muted(gSavedSettings, "MuteMedia");
+    static LLCachedControl<F32> media_volume(gSavedSettings, "AudioLevelMedia");
+    LLViewerMedia::getInstance()->setVolume( media_muted() ? 0.0f : (mute_volume * master_volume() * media_volume()));
 
     // Voice, this is parametric singleton, it gets initialized when ready
     if (LLVoiceClient::instanceExists())
     {
-        F32 voice_volume = gSavedSettings.getF32("AudioLevelVoice");
-        voice_volume = mute_volume * master_volume * voice_volume;
-        bool voice_mute = gSavedSettings.getBOOL("MuteVoice");
+        static LLCachedControl<bool> voice_mute(gSavedSettings, "MuteVoice");
+        static LLCachedControl<F32> voice_volume_setting(gSavedSettings, "AudioLevelVoice");
+        static LLCachedControl<F32> voice_mic_setting(gSavedSettings, "AudioLevelMic");
+        F32 voice_volume = mute_volume * master_volume() * voice_volume_setting();
         LLVoiceClient *voice_inst = LLVoiceClient::getInstance();
-        voice_inst->setVoiceVolume(voice_mute ? 0.f : voice_volume);
-        voice_inst->setMicGain(voice_mute ? 0.f : gSavedSettings.getF32("AudioLevelMic"));
+        voice_inst->setVoiceVolume(voice_mute() ? 0.f : voice_volume);
+        voice_inst->setMicGain(voice_mute() ? 0.f : voice_mic_setting());
 
-        if (!gViewerWindow->getActive() && (gSavedSettings.getBOOL("MuteWhenMinimized")))
+        if (!gViewerWindow->getActive() && mute_when_minimized())
         {
             voice_inst->setMuteMic(true);
         }
diff --git a/indra/newview/llviewerdisplay.cpp b/indra/newview/llviewerdisplay.cpp
index 4c408ec17d..35ac7919ac 100644
--- a/indra/newview/llviewerdisplay.cpp
+++ b/indra/newview/llviewerdisplay.cpp
@@ -240,8 +240,11 @@ void display_stats()
     if (gRecentFPSTime.getElapsedTimeF32() >= FPS_LOG_FREQUENCY)
     {
         LL_PROFILE_ZONE_NAMED_CATEGORY_DISPLAY("DS - FPS");
+        LLTrace::Recording& recording = LLTrace::get_frame_recording().getLastRecording();
+        F64 normalized_session_jitter = recording.getLastValue(LLStatViewer::NOTRMALIZED_FRAMETIME_JITTER_SESSION);
+        F64 normalized_period_jitter = recording.getLastValue(LLStatViewer::NORMALIZED_FRAMTIME_JITTER_PERIOD);
         F32 fps = gRecentFrameCount / FPS_LOG_FREQUENCY;
-        LL_INFOS() << llformat("FPS: %.02f", fps) << LL_ENDL;
+        LL_INFOS() << llformat("FPS: %.02f SESSION JITTER: %.4f PERIOD JITTER: %.4f", fps, normalized_session_jitter, normalized_period_jitter) << LL_ENDL;
         gRecentFrameCount = 0;
         gRecentFPSTime.reset();
     }
diff --git a/indra/newview/llviewermedia.cpp b/indra/newview/llviewermedia.cpp
index d5f63674e9..a77b9f6103 100644
--- a/indra/newview/llviewermedia.cpp
+++ b/indra/newview/llviewermedia.cpp
@@ -83,6 +83,8 @@ extern bool gCubeSnapshot;
 
 // *TODO: Consider enabling mipmaps (they have been disabled for a long time). Likely has a significant performance impact for tiled/high texture repeat media. Mip generation in a shader may also be an option if necessary.
 constexpr bool USE_MIPMAPS = false;
+constexpr S32 MAX_MEDIA_INSTANCES_DEFAULT = 8;
+constexpr S32 MEDIA_INSTANCES_MIN_LIMIT = 6; // 4 'permanent' floaters plus reserve for dynamic ones
 
 void init_threaded_picker_load_dialog(LLPluginClassMedia* plugin, LLFilePicker::ELoadFilter filter, bool get_multiple)
 {
@@ -214,6 +216,7 @@ static bool sViewerMediaMuteListObserverInitialized = false;
 LLViewerMedia::LLViewerMedia():
 mAnyMediaShowing(false),
 mAnyMediaPlaying(false),
+mMaxIntances(MAX_MEDIA_INSTANCES_DEFAULT),
 mSpareBrowserMediaSource(NULL)
 {
 }
@@ -222,6 +225,7 @@ LLViewerMedia::~LLViewerMedia()
 {
     gIdleCallbacks.deleteFunction(LLViewerMedia::onIdle, NULL);
     mTeleportFinishConnection.disconnect();
+    mMaxInstancesConnection.disconnect();
     if (mSpareBrowserMediaSource != NULL)
     {
         delete mSpareBrowserMediaSource;
@@ -235,6 +239,35 @@ void LLViewerMedia::initSingleton()
     gIdleCallbacks.addFunction(LLViewerMedia::onIdle, NULL);
     mTeleportFinishConnection = LLViewerParcelMgr::getInstance()->
         setTeleportFinishedCallback(boost::bind(&LLViewerMedia::onTeleportFinished, this));
+
+    LLControlVariable* ctrl = gSavedSettings.getControl("PluginInstancesTotal");
+    if (ctrl)
+    {
+        setMaxInstances(ctrl->getValue().asInteger());
+        mMaxInstancesConnection = ctrl->getSignal()->connect([this](LLControlVariable* control, const LLSD& new_val, const LLSD& old_val)
+        {
+            setMaxInstances(new_val.asInteger());
+        });
+    }
+    else
+    {
+        setMaxInstances(MAX_MEDIA_INSTANCES_DEFAULT);
+    }
+}
+
+void LLViewerMedia::setMaxInstances(S32 max_instances)
+{
+    const F32Gigabytes MIN_PHYSICAL_MEMORY(8);
+    LLMemory::updateMemoryInfo();
+    F32Gigabytes physical_mem = LLMemory::getMaxMemKB();
+    if (MIN_PHYSICAL_MEMORY > physical_mem)
+    {
+        mMaxIntances = llmax(max_instances - 2, MEDIA_INSTANCES_MIN_LIMIT);
+    }
+    else
+    {
+        mMaxIntances = llmax(max_instances, MEDIA_INSTANCES_MIN_LIMIT);
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -630,9 +663,10 @@ void LLViewerMedia::updateMedia(void *dummy_arg)
     LL_PROFILE_ZONE_SCOPED_CATEGORY_MEDIA; //LL_RECORD_BLOCK_TIME(FTM_MEDIA_UPDATE);
 
     llassert(!gCubeSnapshot);
+    static LLCachedControl<bool> use_read_thread(gSavedSettings, "PluginUseReadThread", true);
 
     // Enable/disable the plugin read thread
-    LLPluginProcessParent::setUseReadThread(gSavedSettings.getBOOL("PluginUseReadThread"));
+    LLPluginProcessParent::setUseReadThread(use_read_thread());
 
     // SL-16418 We can't call LLViewerMediaImpl->update() if we are in the state of shutting down.
     if(LLApp::isExiting())
@@ -688,7 +722,6 @@ void LLViewerMedia::updateMedia(void *dummy_arg)
 
     static LLCachedControl<bool> inworld_media_enabled(gSavedSettings, "AudioStreamingMedia", true);
     static LLCachedControl<bool> inworld_audio_enabled(gSavedSettings, "AudioStreamingMusic", true);
-    static LLCachedControl<U32> max_instances(gSavedSettings, "PluginInstancesTotal", 8);
     static LLCachedControl<U32> max_normal(gSavedSettings, "PluginInstancesNormal", 2);
     static LLCachedControl<U32> max_low(gSavedSettings, "PluginInstancesLow", 4);
     static LLCachedControl<F32> max_cpu(gSavedSettings, "PluginInstancesCPULimit", 0.9);
@@ -709,7 +742,7 @@ void LLViewerMedia::updateMedia(void *dummy_arg)
 
             LLPluginClassMedia::EPriority new_priority = LLPluginClassMedia::PRIORITY_NORMAL;
 
-            if(pimpl->isForcedUnloaded() || (impl_count_total >= (int)max_instances))
+            if(pimpl->isForcedUnloaded() || (impl_count_total >= mMaxIntances))
             {
                 // Never load muted or failed impls.
                 // Hard limit on the number of instances that will be loaded at one time
@@ -869,7 +902,7 @@ void LLViewerMedia::updateMedia(void *dummy_arg)
     sLowestLoadableImplInterest = 0.0f;
 
     // Only do this calculation if we've hit the impl count limit -- up until that point we always need to load media data.
-    if(lowest_interest_loadable && (impl_count_total >= (int)max_instances))
+    if(lowest_interest_loadable && (impl_count_total >= mMaxIntances))
     {
         // Get the interest value of this impl's object for use by isInterestingEnough
         LLVOVolume *object = lowest_interest_loadable->getSomeObject();
@@ -1201,6 +1234,54 @@ LLCore::HttpHeaders::ptr_t LLViewerMedia::getHttpHeaders()
     return headers;
 }
 
+bool LLViewerMedia::getOpenIDCookie(LLMediaCtrl* media_instance) const
+{
+    if (mOpenIDCookie.empty())
+    {
+        return false;
+    }
+
+    std::string authority = mOpenIDURL.mAuthority;
+    std::string::size_type hostStart = authority.find('@');
+    if (hostStart == std::string::npos)
+    {
+        // no username/password
+        hostStart = 0;
+    }
+    else
+    {
+        // Hostname starts after the @.
+        // (If the hostname part is empty, this may put host_start at the end of the string.  In that case, it will end up passing through an empty hostname, which is correct.)
+        ++hostStart;
+    }
+    std::string::size_type hostEnd = authority.rfind(':');
+    if ((hostEnd == std::string::npos) || (hostEnd < hostStart))
+    {
+        // no port
+        hostEnd = authority.size();
+    }
+
+    std::string cookie_host = authority.substr(hostStart, hostEnd - hostStart);
+    std::string cookie_name = "";
+    std::string cookie_value = "";
+    std::string cookie_path = "";
+    bool httponly = true;
+    bool secure = true;
+    if (!parseRawCookie(mOpenIDCookie, cookie_name, cookie_value, cookie_path, httponly, secure))
+    {
+        return false;
+    }
+    std::string cefUrl(std::string(mOpenIDURL.mURI) + "://" + std::string(mOpenIDURL.mAuthority));
+    if (media_instance && media_instance->getMediaPlugin())
+    {
+        media_instance->getMediaPlugin()->setCookie(cefUrl, cookie_name, cookie_value, cookie_host,
+            cookie_path, httponly, secure);
+
+        media_instance->getMediaPlugin()->storeOpenIDCookie(cefUrl, cookie_name, cookie_value,
+            cookie_host, cookie_path, httponly, secure);
+    }
+    return true;
+}
 
 /////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerMedia::setOpenIDCookie(const std::string& url)
@@ -1267,7 +1348,7 @@ void LLViewerMedia::getOpenIDCookieCoro(std::string url)
                 bool secure = true;
 
                 LLViewerMedia* inst = getInstance();
-                if (inst->parseRawCookie(inst->mOpenIDCookie, cookie_name, cookie_value, cookie_path, httponly, secure))
+                if (parseRawCookie(inst->mOpenIDCookie, cookie_name, cookie_value, cookie_path, httponly, secure))
                 {
                     // MAINT-5711 - inexplicably, the CEF setCookie function will no longer set the cookie if the
                     // url and domain are not the same. This used to be my.sl.com and id.sl.com respectively and worked.
@@ -1284,20 +1365,24 @@ void LLViewerMedia::getOpenIDCookieCoro(std::string url)
                         std::string browser_name;
                     };
                     struct MediaCookieInstance media_cookie_instances[] = {
-                        {"search", "search_contents" },
-                        {"marketplace", "marketplace_contents" },
+                        {"search", "webbrowser" },
+                        {"marketplace", "webbrowser" },
                         {"destinations", "destination_guide_contents" },
                     };
                     for (MediaCookieInstance mci : media_cookie_instances)
                     {
-                        LLMediaCtrl* media_instance = LLFloaterReg::getInstance(mci.floater_name)->getChild<LLMediaCtrl>(mci.browser_name);
-                        if (media_instance && media_instance->getMediaPlugin())
+                        LLFloater *floaterp = LLFloaterReg::findInstance(mci.floater_name);
+                        if (floaterp)
                         {
-                            media_instance->getMediaPlugin()->setCookie(cefUrl, cookie_name, cookie_value, cookie_host,
-                                cookie_path, httponly, secure);
+                            LLMediaCtrl* media_instance = floaterp->getChild<LLMediaCtrl>(mci.browser_name);
+                            if (media_instance && media_instance->getMediaPlugin())
+                            {
+                                media_instance->getMediaPlugin()->setCookie(cefUrl, cookie_name, cookie_value, cookie_host,
+                                    cookie_path, httponly, secure);
 
-                            media_instance->getMediaPlugin()->storeOpenIDCookie(cefUrl, cookie_name, cookie_value,
-                                cookie_host, cookie_path, httponly, secure);
+                                media_instance->getMediaPlugin()->storeOpenIDCookie(cefUrl, cookie_name, cookie_value,
+                                    cookie_host, cookie_path, httponly, secure);
+                            }
                         }
                     }
                 }
@@ -2105,16 +2190,19 @@ void LLViewerMediaImpl::updateVolume()
 
         if (mProximityCamera > 0)
         {
-            if (mProximityCamera > gSavedSettings.getF32("MediaRollOffMax"))
+            static LLCachedControl<F32> media_rolloff_min(gSavedSettings, "MediaRollOffMin");
+            static LLCachedControl<F32> media_rolloff_max(gSavedSettings, "MediaRollOffMax");
+            static LLCachedControl<F32> media_rolloff_rate(gSavedSettings, "MediaRollOffRate");
+            if (mProximityCamera > media_rolloff_max())
             {
                 volume = 0;
             }
-            else if (mProximityCamera > gSavedSettings.getF32("MediaRollOffMin"))
+            else if (mProximityCamera > media_rolloff_min())
             {
                 // attenuated_volume = 1 / (roll_off_rate * (d - min))^2
                 // the +1 is there so that for distance 0 the volume stays the same
-                F64 adjusted_distance = mProximityCamera - gSavedSettings.getF32("MediaRollOffMin");
-                F64 attenuation = 1.0 + (gSavedSettings.getF32("MediaRollOffRate") * adjusted_distance);
+                F64 adjusted_distance = mProximityCamera - media_rolloff_min();
+                F64 attenuation = 1.0 + (media_rolloff_rate() * adjusted_distance);
                 attenuation = 1.0 / (attenuation * attenuation);
                 // the attenuation multiplier should never be more than one since that would increase volume
                 volume = volume * (F32)llmin(1.0, attenuation);
@@ -3001,7 +3089,10 @@ void LLViewerMediaImpl::doMediaTexUpdate(LLViewerMediaTexture* media_tex, U8* da
     // -Cosmic,2023-04-04
     // Allocate GL texture based on LLImageRaw but do NOT copy to GL
     LLGLuint tex_name = 0;
-    media_tex->createGLTexture(0, raw, 0, true, LLGLTexture::OTHER, true, &tex_name);
+    if (!media_tex->createGLTexture(0, raw, 0, true, LLGLTexture::OTHER, true, &tex_name))
+    {
+        LL_WARNS("Media") << "Failed to create media texture" << LL_ENDL;
+    }
 
     // copy just the subimage covered by the image raw to GL
     media_tex->setSubImage(data, data_width, data_height, x_pos, y_pos, width, height, tex_name);
@@ -3070,7 +3161,10 @@ LLViewerMediaTexture* LLViewerMediaImpl::updateMediaImage()
             mMediaSource->getTextureFormatSwapBytes());
 
         int discard_level = 0;
-        media_tex->createGLTexture(discard_level, raw);
+        if (!media_tex->createGLTexture(discard_level, raw))
+        {
+            LL_WARNS("Media") << "Failed to create media texture" << LL_ENDL;
+        }
 
         // MEDIAOPT: set this dynamically on play/stop
         // FIXME
diff --git a/indra/newview/llviewermedia.h b/indra/newview/llviewermedia.h
index c17cf59815..1fc5bbc9e0 100644
--- a/indra/newview/llviewermedia.h
+++ b/indra/newview/llviewermedia.h
@@ -69,6 +69,7 @@ private:
 };
 
 class LLViewerMediaImpl;
+class LLMediaCtrl;
 
 class LLViewerMedia: public LLSingleton<LLViewerMedia>
 {
@@ -162,22 +163,26 @@ public:
 
     LLSD getHeaders();
     LLCore::HttpHeaders::ptr_t getHttpHeaders();
+    bool getOpenIDCookie(LLMediaCtrl* media_instance) const;
 
 private:
     void onAuthSubmit(const LLSD& notification, const LLSD& response);
-    bool parseRawCookie(const std::string raw_cookie, std::string& name, std::string& value, std::string& path, bool& httponly, bool& secure);
+    static bool parseRawCookie(const std::string raw_cookie, std::string& name, std::string& value, std::string& path, bool& httponly, bool& secure);
     void setOpenIDCookie(const std::string& url);
     void onTeleportFinished();
 
     static void openIDSetupCoro(std::string openidUrl, std::string openidToken);
     static void getOpenIDCookieCoro(std::string url);
+    void setMaxInstances(S32 max_instances);
 
     bool mAnyMediaShowing;
     bool mAnyMediaPlaying;
+    S32 mMaxIntances = 8;
     LLURL mOpenIDURL;
     std::string mOpenIDCookie;
     LLPluginClassMedia* mSpareBrowserMediaSource;
     boost::signals2::connection mTeleportFinishConnection;
+    boost::signals2::connection mMaxInstancesConnection;
 };
 
 // Implementation functions not exported into header file
diff --git a/indra/newview/llviewernetwork.cpp b/indra/newview/llviewernetwork.cpp
index f11fa09ce9..890580ddff 100644
--- a/indra/newview/llviewernetwork.cpp
+++ b/indra/newview/llviewernetwork.cpp
@@ -69,7 +69,7 @@ const std::string MAIN_GRID_LOGIN_URI = "https://login.agni.lindenlab.com/cgi-bi
 
 const std::string SL_UPDATE_QUERY_URL = "https://update.secondlife.com/update";
 
-const std::string MAIN_GRID_SLURL_BASE = "http://maps.secondlife.com/secondlife/";
+const std::string MAIN_GRID_SLURL_BASE = "https://maps.secondlife.com/secondlife/";
 const std::string SYSTEM_GRID_APP_SLURL_BASE = "secondlife:///app";
 
 const std::string MAIN_GRID_WEB_PROFILE_URL = "https://my.secondlife.com/";
@@ -281,7 +281,7 @@ bool LLGridManager::addGrid(LLSD& grid_data)
                 // Populate to the default values
                 if (!grid_data.has(GRID_LOGIN_PAGE_VALUE))
                 {
-                    grid_data[GRID_LOGIN_PAGE_VALUE] = std::string("http://") + grid + "/app/login/";
+                    grid_data[GRID_LOGIN_PAGE_VALUE] = std::string("https://") + grid + "/app/login/";
                 }
                 if (!grid_data.has(GRID_HELPER_URI_VALUE))
                 {
diff --git a/indra/newview/llviewerobject.cpp b/indra/newview/llviewerobject.cpp
index 1675c44c5c..06089e48b8 100644
--- a/indra/newview/llviewerobject.cpp
+++ b/indra/newview/llviewerobject.cpp
@@ -7469,9 +7469,10 @@ const std::string& LLViewerObject::getAttachmentItemName() const
 LLVOAvatar* LLViewerObject::getAvatar() const
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_AVATAR;
-    if (getControlAvatar())
+    LLControlAvatar* ca = getControlAvatar();
+    if (ca)
     {
-        return getControlAvatar();
+        return ca;
     }
     if (isAttachment())
     {
diff --git a/indra/newview/llviewerparcelmgr.cpp b/indra/newview/llviewerparcelmgr.cpp
index 432da2e990..6a029645fb 100644
--- a/indra/newview/llviewerparcelmgr.cpp
+++ b/indra/newview/llviewerparcelmgr.cpp
@@ -881,7 +881,8 @@ LLParcel* LLViewerParcelMgr::getCollisionParcel() const
 
 void LLViewerParcelMgr::render()
 {
-    if (mSelected && mRenderSelection && gSavedSettings.getBOOL("RenderParcelSelection") && !gDisconnected)
+    static LLCachedControl<bool> render_parcel_selection(gSavedSettings, "RenderParcelSelection");
+    if (mSelected && mRenderSelection && render_parcel_selection() && !gDisconnected)
     {
         // Rendering is done in agent-coordinates, so need to supply
         // an appropriate offset to the render code.
diff --git a/indra/newview/llviewerstats.h b/indra/newview/llviewerstats.h
index 011269d7ee..1ac8b2f66b 100644
--- a/indra/newview/llviewerstats.h
+++ b/indra/newview/llviewerstats.h
@@ -229,6 +229,9 @@ extern LLTrace::EventStatHandle<F64Seconds >    AVATAR_EDIT_TIME,
 
 extern LLTrace::EventStatHandle<LLUnit<F32, LLUnits::Percent> > OBJECT_CACHE_HIT_RATE;
 
+extern LLTrace::SampleStatHandle<F64> NOTRMALIZED_FRAMETIME_JITTER_SESSION;
+extern LLTrace::SampleStatHandle<F64> NORMALIZED_FRAMTIME_JITTER_PERIOD;
+
 }
 
 class LLViewerStats : public LLSingleton<LLViewerStats>
diff --git a/indra/newview/llviewertexture.cpp b/indra/newview/llviewertexture.cpp
index 6135e18840..1e83482752 100644
--- a/indra/newview/llviewertexture.cpp
+++ b/indra/newview/llviewertexture.cpp
@@ -406,7 +406,10 @@ void LLViewerTextureManager::init()
             }
         }
     }
-    imagep->createGLTexture(0, image_raw);
+    if (!imagep->createGLTexture(0, image_raw))
+    {
+        LL_WARNS() << "Failed to create default texture " << IMG_DEFAULT << LL_ENDL;
+    }
     image_raw = NULL;
 #else
     LLViewerFetchedTexture::sDefaultImagep = LLViewerTextureManager::getFetchedTexture(IMG_DEFAULT, true, LLGLTexture::BOOST_UI);
diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp
index 209abe5dea..ec5cff65aa 100644
--- a/indra/newview/llviewerwindow.cpp
+++ b/indra/newview/llviewerwindow.cpp
@@ -1882,8 +1882,10 @@ LLViewerWindow::LLViewerWindow(const Params& p)
     // gKeyboard is still NULL, so it doesn't do LLWindowListener any good to
     // pass its value right now. Instead, pass it a nullary function that
     // will, when we later need it, return the value of gKeyboard.
-    LLWindowListener::KeyboardGetter getter = []() { return gKeyboard; };
+    // boost::lambda::var() constructs such a functor on the fly.
+    LLWindowListener::KeyboardGetter getter = [](){ return gKeyboard; };
     mWindowListener = std::make_unique<LLWindowListener>(this, getter);
+    mViewerWindowListener = std::make_unique<LLViewerWindowListener>(this);
 
     mSystemChannel.reset(new LLNotificationChannel("System", "Visible", LLNotificationFilters::includeEverything));
     mCommunicationChannel.reset(new LLCommunicationChannel("Communication", "Visible"));
@@ -2321,36 +2323,23 @@ void LLViewerWindow::initWorldUI()
         gToolBarView->setVisible(true);
     }
 
-    if (!gNonInteractive)
+    // Don't preload cef instances on low end hardware
+    const F32Gigabytes MIN_PHYSICAL_MEMORY(8);
+    F32Gigabytes physical_mem = LLMemory::getMaxMemKB();
+    if (physical_mem <= 0)
     {
-        LLMediaCtrl* destinations = LLFloaterReg::getInstance("destinations")->getChild<LLMediaCtrl>("destination_guide_contents");
-        if (destinations)
-        {
-            destinations->setErrorPageURL(gSavedSettings.getString("GenericErrorPageURL"));
-            std::string url = gSavedSettings.getString("DestinationGuideURL");
-            url = LLWeb::expandURLSubstitutions(url, LLSD());
-            destinations->navigateTo(url, HTTP_CONTENT_TEXT_HTML);
-        }
-        LLMediaCtrl* avatar_welcome_pack = LLFloaterReg::getInstance("avatar_welcome_pack")->findChild<LLMediaCtrl>("avatar_picker_contents");
-        if (avatar_welcome_pack)
-        {
-            avatar_welcome_pack->setErrorPageURL(gSavedSettings.getString("GenericErrorPageURL"));
-            std::string url = gSavedSettings.getString("AvatarWelcomePack");
-            url = LLWeb::expandURLSubstitutions(url, LLSD());
-            avatar_welcome_pack->navigateTo(url, HTTP_CONTENT_TEXT_HTML);
-        }
-        LLMediaCtrl* search = LLFloaterReg::getInstance("search")->findChild<LLMediaCtrl>("search_contents");
-        if (search)
-        {
-            search->setErrorPageURL(gSavedSettings.getString("GenericErrorPageURL"));
-        }
-        LLMediaCtrl* marketplace = LLFloaterReg::getInstance("marketplace")->getChild<LLMediaCtrl>("marketplace_contents");
-        if (marketplace)
-        {
-            marketplace->setErrorPageURL(gSavedSettings.getString("GenericErrorPageURL"));
-            std::string url = gSavedSettings.getString("MarketplaceURL");
-            marketplace->navigateTo(url, HTTP_CONTENT_TEXT_HTML);
-        }
+        LLMemory::updateMemoryInfo();
+        physical_mem = LLMemory::getMaxMemKB();
+    }
+
+    if (!gNonInteractive && physical_mem > MIN_PHYSICAL_MEMORY)
+    {
+        LL_INFOS() << "Preloading cef instances" << LL_ENDL;
+
+        LLFloaterReg::getInstance("destinations");
+        LLFloaterReg::getInstance("avatar_welcome_pack");
+        LLFloaterReg::getInstance("search");
+        LLFloaterReg::getInstance("marketplace");
     }
 }
 
@@ -3340,7 +3329,7 @@ void LLViewerWindow::clearPopups()
 void LLViewerWindow::moveCursorToCenter()
 {
     bool mouse_warp = false;
-    LLCachedControl<S32> mouse_warp_mode(gSavedSettings, "MouseWarpMode", 1);
+    static LLCachedControl<S32> mouse_warp_mode(gSavedSettings, "MouseWarpMode", 1);
 
     switch (mouse_warp_mode())
     {
@@ -3413,13 +3402,11 @@ void append_xui_tooltip(LLView* viewp, LLToolTip::Params& params)
     }
 }
 
-static LLTrace::BlockTimerStatHandle ftm("Update UI");
-
 // Update UI based on stored mouse position from mouse-move
 // event processing.
 void LLViewerWindow::updateUI()
 {
-    LL_PROFILE_ZONE_SCOPED_CATEGORY_UI; //LL_RECORD_BLOCK_TIME(ftm);
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_UI;
 
     static std::string last_handle_msg;
 
@@ -3437,12 +3424,15 @@ void LLViewerWindow::updateUI()
         }
     }
 
-    LLConsole::updateClass();
+    {
+        LL_PROFILE_ZONE_NAMED("UI updateClass");
+        LLConsole::updateClass();
 
-    // execute postponed arrange calls
-    LLAccordionCtrl::updateClass();
-    // animate layout stacks so we have up to date rect for world view
-    LLLayoutStack::updateClass();
+        // execute postponed arrange calls
+        LLAccordionCtrl::updateClass();
+        // animate layout stacks so we have up to date rect for world view
+        LLLayoutStack::updateClass();
+    }
 
     // use full window for world view when not rendering UI
     bool world_view_uses_full_window = gAgentCamera.cameraMouselook() || !gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_UI);
@@ -3871,6 +3861,7 @@ void LLViewerWindow::updateUI()
 
 void LLViewerWindow::updateLayout()
 {
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_UI;
     LLTool* tool = LLToolMgr::getInstance()->getCurrentTool();
     if (gFloaterTools != NULL
         && tool != NULL
diff --git a/indra/newview/llvoicewebrtc.cpp b/indra/newview/llvoicewebrtc.cpp
index 3efcd763e3..80a0e3e5c0 100644
--- a/indra/newview/llvoicewebrtc.cpp
+++ b/indra/newview/llvoicewebrtc.cpp
@@ -2549,10 +2549,7 @@ void LLVoiceWebRTCConnection::OnRenegotiationNeeded()
     LL::WorkQueue::postMaybe(mMainQueue,
         [=, this] {
             LL_DEBUGS("Voice") << "Voice channel requires renegotiation." << LL_ENDL;
-            if (!mShutDown)
-            {
-                setVoiceConnectionState(VOICE_STATE_SESSION_RETRY);
-            }
+            setVoiceConnectionState(VOICE_STATE_SESSION_RETRY);
             mCurrentStatus = LLVoiceClientStatusObserver::ERROR_UNKNOWN;
         });
 }
@@ -2898,9 +2895,10 @@ bool LLVoiceWebRTCConnection::connectionStateMachine()
             // this connection.
             // For spatial this connection will come up as muted, but will be set to the appropriate
             // value later on when we determine the regions we connect to.
-            if (!isSpatial())
+            if (isSpatial())
             {
-                mWebRTCAudioInterface->setMute(mMuted);
+                // we'll determine primary state later and set mute accordinly
+                mPrimary = false;
             }
             mWebRTCAudioInterface->setReceiveVolume(mSpeakerVolume);
             LLWebRTCVoiceClient::getInstance()->OnConnectionEstablished(mChannelID, mRegionID);
@@ -2924,6 +2922,10 @@ bool LLVoiceWebRTCConnection::connectionStateMachine()
                     LLWebRTCVoiceClient::getInstance()->updatePosition();
                     LLWebRTCVoiceClient::getInstance()->sendPositionUpdate(true);
                 }
+                else
+                {
+                    mWebRTCAudioInterface->setMute(mMuted);
+                }
             }
             break;
         }
diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index 89cc05802d..06259f5446 100644
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -2693,10 +2693,10 @@ void LLVOVolume::mediaNavigateBounceBack(U8 texture_index)
     if (mep && impl)
     {
         std::string url = mep->getCurrentURL();
-        // Look for a ":", if not there, assume "http://"
+        // Look for a ":", if not there, assume "https://"
         if (!url.empty() && std::string::npos == url.find(':'))
         {
-            url = "http://" + url;
+            url = "https://" + url;
         }
         // If the url we're trying to "bounce back" to is either empty or not
         // allowed by the whitelist, try the home url.  If *that* doesn't work,
@@ -2704,10 +2704,10 @@ void LLVOVolume::mediaNavigateBounceBack(U8 texture_index)
         if (url.empty() || !mep->checkCandidateUrl(url))
         {
             url = mep->getHomeURL();
-            // Look for a ":", if not there, assume "http://"
+            // Look for a ":", if not there, assume "https://"
             if (!url.empty() && std::string::npos == url.find(':'))
             {
-                url = "http://" + url;
+                url = "https://" + url;
             }
         }
         if (url.empty() || !mep->checkCandidateUrl(url))
@@ -3842,11 +3842,12 @@ void LLVOVolume::onReparent(LLViewerObject *old_parent, LLViewerObject *new_pare
     }
     if (old_volp && old_volp->isAnimatedObject())
     {
-        if (old_volp->getControlAvatar())
+        LLControlAvatar* cav = old_volp->getControlAvatar();
+        if (cav)
         {
             // We have been removed from an animated object, need to do cleanup.
-            old_volp->getControlAvatar()->updateAttachmentOverrides();
-            old_volp->getControlAvatar()->updateAnimations();
+            cav->updateAttachmentOverrides();
+            cav->updateAnimations();
         }
     }
 }
@@ -5131,7 +5132,7 @@ U32 LLVOVolume::getPartitionType() const
     {
         return LLViewerRegion::PARTITION_HUD;
     }
-    if (isAnimatedObject() && getControlAvatar())
+    if (isAnimatedObjectFast() && getControlAvatar())
     {
         return LLViewerRegion::PARTITION_CONTROL_AV;
     }
@@ -5757,11 +5758,18 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
             }
 
             // Standard rigged mesh attachments:
-            bool rigged = !vobj->isAnimatedObject() && skinInfo && vobj->isAttachment();
+            bool is_animated = vobj->isAnimatedObject();
+            bool rigged = !is_animated && skinInfo && vobj->isAttachment();
             // Animated objects. Have to check for isRiggedMesh() to
             // exclude static objects in animated object linksets.
-            rigged = rigged || (vobj->isAnimatedObject() && vobj->isRiggedMesh() &&
-                vobj->getControlAvatar() && vobj->getControlAvatar()->mPlaying);
+            if (!rigged && is_animated && vobj->isRiggedMesh())
+            {
+                LLControlAvatar* cav = vobj->getControlAvatar();
+                if (cav)
+                {
+                    rigged = cav->mPlaying;
+                }
+            }
 
             bool any_rigged_face = false;
 
diff --git a/indra/newview/llwatchdog.cpp b/indra/newview/llwatchdog.cpp
index bf171fe954..614d1afc2a 100644
--- a/indra/newview/llwatchdog.cpp
+++ b/indra/newview/llwatchdog.cpp
@@ -28,6 +28,7 @@
 #include "llviewerprecompiledheaders.h"
 #include "llwatchdog.h"
 #include "llthread.h"
+#include "llappviewer.h"
 
 constexpr U32 WATCHDOG_SLEEP_TIME_USEC = 1000000U;
 
@@ -240,7 +241,16 @@ void LLWatchdog::run()
             {
                 mTimer->stop();
             }
-
+            if (LLAppViewer::instance()->logoutRequestSent())
+            {
+                LLAppViewer::instance()->createErrorMarker(LAST_EXEC_LOGOUT_FROZE);
+            }
+            else
+            {
+                LLAppViewer::instance()->createErrorMarker(LAST_EXEC_FROZE);
+            }
+            // Todo1: warn user?
+            // Todo2: We probably want to report even if 5 seconds passed, just not error 'yet'.
             LL_ERRS() << "Watchdog timer expired; assuming viewer is hung and crashing" << LL_ENDL;
         }
     }
diff --git a/indra/newview/llwindowlistener.cpp b/indra/newview/llwindowlistener.cpp
index edaa44aa70..6d234a9a34 100644
--- a/indra/newview/llwindowlistener.cpp
+++ b/indra/newview/llwindowlistener.cpp
@@ -54,7 +54,7 @@ LLWindowListener::LLWindowListener(LLViewerWindow *window, const KeyboardGetter&
         "Given [\"keysym\"], [\"keycode\"] or [\"char\"], inject the specified ";
     std::string keyExplain =
         "(integer keycode values, or keysym string from any addKeyName() call in\n"
-        "http://bitbucket.org/lindenlab/viewer-release/src/tip/indra/llwindow/llkeyboard.cpp )\n";
+        "https://github.com/secondlife/viewer/blob/develop/indra/llwindow/llkeyboard.cpp )\n";
     std::string mask =
         "Specify optional [\"mask\"] as an array containing any of \"CTL\", \"ALT\",\n"
         "\"SHIFT\" or \"MAC_CONTROL\"; the corresponding modifier bits will be combined\n"
@@ -69,7 +69,7 @@ LLWindowListener::LLWindowListener(LLViewerWindow *window, const KeyboardGetter&
         "(button values \"LEFT\", \"MIDDLE\", \"RIGHT\")\n";
     std::string paramsExplain =
         "[\"path\"] is as for LLUI::getInstance()->resolvePath(), described in\n"
-        "http://bitbucket.org/lindenlab/viewer-release/src/tip/indra/llui/llui.h\n"
+        "https://github.com/secondlife/viewer/blob/develop/indra/llui/llui.h\n"
         "If you omit [\"path\"], you must specify both [\"x\"] and [\"y\"].\n"
         "If you specify [\"path\"] without both [\"x\"] and [\"y\"], will synthesize (x, y)\n"
         "in the center of the LLView selected by [\"path\"].\n"
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index d2aebfbce5..d1ea8c2ee5 100644
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -5525,7 +5525,7 @@ static F32 calc_light_dist(LLVOVolume* light, const LLVector3& cam_pos, F32 max_
     if (light->mDrawable.notNull() && light->mDrawable->isState(LLDrawable::ACTIVE))
     {
         // moving lights get a little higher priority (too much causes artifacts)
-        dist = llmax(dist - light->getLightRadius()*0.25f, 0.f);
+        dist = llmax(dist - radius * 0.25f, 0.f);
     }
     return dist;
 }
diff --git a/indra/newview/skins/default/xui/en/floater_marketplace.xml b/indra/newview/skins/default/xui/en/floater_marketplace.xml
index 99fb3a1ad8..40bf674d2d 100644
--- a/indra/newview/skins/default/xui/en/floater_marketplace.xml
+++ b/indra/newview/skins/default/xui/en/floater_marketplace.xml
@@ -169,7 +169,7 @@
         follows="all"
         layout="topleft"
         left="0"
-        name="marketplace_contents"
+        name="webbrowser"
         top="0"/>
     </layout_panel>
     <layout_panel name="status_bar" 
diff --git a/indra/newview/skins/default/xui/en/floater_search.xml b/indra/newview/skins/default/xui/en/floater_search.xml
index 43c4aa1b9d..8891ebcd87 100644
--- a/indra/newview/skins/default/xui/en/floater_search.xml
+++ b/indra/newview/skins/default/xui/en/floater_search.xml
@@ -170,7 +170,7 @@
         layout="topleft"
         left="0"
         trusted_content="true"
-        name="search_contents"
+        name="webbrowser"
         top="0"/>
     </layout_panel>
     <layout_panel name="status_bar" 
diff --git a/indra/newview/skins/default/xui/en/floater_test_combobox.xml b/indra/newview/skins/default/xui/en/floater_test_combobox.xml
index 4211d624ac..0d75685223 100644
--- a/indra/newview/skins/default/xui/en/floater_test_combobox.xml
+++ b/indra/newview/skins/default/xui/en/floater_test_combobox.xml
@@ -155,4 +155,36 @@
          name="item3"
          value="tx" />
     </combo_box>
+    <text
+     type="string"
+     length="1"
+     height="16"
+     layout="topleft"
+     left_delta="0"
+     top_pad="24"
+     width="200">
+        Multiple columns:
+    </text>
+    <combo_box
+      name="multi_column_combo"
+      layout="topleft"
+      height="20"
+      width="150"
+      left_delta="0"
+      top_pad="4">
+        <combo_item  name="combo_item1" value="0">
+        <column width="40"  name="label"    label="|Abc|" />
+        <column name="longtext" label="Match full text" />
+        </combo_item>
+
+        <combo_item  name="combo_item2" value="1">
+        <column name="label"    label="*Abc*" />
+        <column name="longtext" label="Match substring" />
+        </combo_item>
+
+        <combo_item  name="combo_item3" value="2">
+        <column name="label"    label="/ *. /" />
+        <column name="longtext" label="Match regular expression" />
+        </combo_item>
+    </combo_box>
 </floater>
diff --git a/indra/newview/skins/default/xui/en/panel_group_general.xml b/indra/newview/skins/default/xui/en/panel_group_general.xml
index 7290cbb5c6..74bc7736f9 100644
--- a/indra/newview/skins/default/xui/en/panel_group_general.xml
+++ b/indra/newview/skins/default/xui/en/panel_group_general.xml
@@ -86,6 +86,15 @@ Hover your mouse over the options for more help.
      name="btn_join"
      visible="true"
      width="120" />
+    <button
+     follows="left|top"
+     left_pad="6"
+     top_delta="0"
+     height="23"
+     label="Activate"
+     name="btn_activate"
+     visible="true"
+     width="120" />
     </panel>
     <text_editor
      type="string"
diff --git a/indra/newview/skins/default/xui/en/panel_preferences_move.xml b/indra/newview/skins/default/xui/en/panel_preferences_move.xml
index 3a5a8cbfec..2fc859f43e 100644
--- a/indra/newview/skins/default/xui/en/panel_preferences_move.xml
+++ b/indra/newview/skins/default/xui/en/panel_preferences_move.xml
@@ -214,7 +214,7 @@
    left_pad="10"
    top_delta="-6"
    name="mouse_warp_combo"
-   tooltip="Controls warping of the mouse to the center of the screen during alt-zoom and mouse look."
+   tool_tip="Controls warping of the mouse to the center of the screen during alt-zoom and mouse look."
    width="200">
     <combo_box.item
      label="Automatic"
diff --git a/indra/newview/tests/llslurl_test.cpp b/indra/newview/tests/llslurl_test.cpp
index fc9f5b707a..3ff38ea372 100644
--- a/indra/newview/tests/llslurl_test.cpp
+++ b/indra/newview/tests/llslurl_test.cpp
@@ -177,15 +177,15 @@ namespace tut
         LLSLURL slurl = LLSLURL("");
         ensure_equals("null slurl", (int)slurl.getType(), LLSLURL::LAST_LOCATION);
 
-        slurl = LLSLURL("http://slurl.com/secondlife/myregion");
+        slurl = LLSLURL("https://slurl.com/secondlife/myregion");
         ensure_equals("slurl.com slurl, region only - type", slurl.getType(), LLSLURL::LOCATION);
         ensure_equals("slurl.com slurl, region only", slurl.getSLURLString(),
-                      "http://maps.secondlife.com/secondlife/myregion/128/128/0");
+                      "https://maps.secondlife.com/secondlife/myregion/128/128/0");
 
-        slurl = LLSLURL("http://maps.secondlife.com/secondlife/myregion/1/2/3");
+        slurl = LLSLURL("https://maps.secondlife.com/secondlife/myregion/1/2/3");
         ensure_equals("maps.secondlife.com slurl, region + coords - type", slurl.getType(), LLSLURL::LOCATION);
         ensure_equals("maps.secondlife.com slurl, region + coords", slurl.getSLURLString(),
-                      "http://maps.secondlife.com/secondlife/myregion/1/2/3");
+                      "https://maps.secondlife.com/secondlife/myregion/1/2/3");
 
         slurl = LLSLURL("secondlife://");
         ensure_equals("secondlife: slurl, empty - type", slurl.getType(), LLSLURL::EMPTY);
@@ -196,27 +196,27 @@ namespace tut
         slurl = LLSLURL("secondlife://myregion");
         ensure_equals("secondlife: slurl, region only - type", slurl.getType(), LLSLURL::LOCATION);
         ensure_equals("secondlife: slurl, region only", slurl.getSLURLString(),
-                      "http://maps.secondlife.com/secondlife/myregion/128/128/0");
+                      "https://maps.secondlife.com/secondlife/myregion/128/128/0");
 
         slurl = LLSLURL("secondlife://myregion/1/2/3");
         ensure_equals("secondlife: slurl, region + coords - type", slurl.getType(), LLSLURL::LOCATION);
         ensure_equals("secondlife slurl, region + coords", slurl.getSLURLString(),
-                      "http://maps.secondlife.com/secondlife/myregion/1/2/3");
+                      "https://maps.secondlife.com/secondlife/myregion/1/2/3");
 
         slurl = LLSLURL("/myregion");
         ensure_equals("/region slurl, region- type", slurl.getType(), LLSLURL::LOCATION);
         ensure_equals("/region slurl, region ", slurl.getSLURLString(),
-                      "http://maps.secondlife.com/secondlife/myregion/128/128/0");
+                      "https://maps.secondlife.com/secondlife/myregion/128/128/0");
 
         slurl = LLSLURL("/myregion/1/2/3");
         ensure_equals("/: slurl, region + coords - type", slurl.getType(), LLSLURL::LOCATION);
         ensure_equals("/ slurl, region + coords", slurl.getSLURLString(),
-                      "http://maps.secondlife.com/secondlife/myregion/1/2/3");
+                      "https://maps.secondlife.com/secondlife/myregion/1/2/3");
 
         slurl = LLSLURL("my region/1/2/3");
         ensure_equals(" slurl, region + coords - type", slurl.getType(), LLSLURL::LOCATION);
         ensure_equals(" slurl, region + coords", slurl.getSLURLString(),
-                      "http://maps.secondlife.com/secondlife/my%20region/1/2/3");
+                      "https://maps.secondlife.com/secondlife/my%20region/1/2/3");
 
         LLGridManager::getInstance()->setGridChoice("my.grid.com");
         slurl = LLSLURL("https://my.grid.com/region/my%20region/1/2/3");
@@ -309,7 +309,7 @@ namespace tut
         slurl = LLSLURL("my region", LLVector3(1,2,3));
         ensure_equals("default grid/region/vector - type", slurl.getType(), LLSLURL::LOCATION);
         ensure_equals(" default grid/region/vector", slurl.getSLURLString(),
-                      "http://maps.secondlife.com/secondlife/my%20region/1/2/3");
+                      "https://maps.secondlife.com/secondlife/my%20region/1/2/3");
 
         LLGridManager::getInstance()->setGridChoice("MyGrid");
         slurl = LLSLURL("my region", LLVector3(1,2,3));
diff --git a/indra/newview/tests/llviewernetwork_test.cpp b/indra/newview/tests/llviewernetwork_test.cpp
index d9cb9e7538..94cf0fcf10 100644
--- a/indra/newview/tests/llviewernetwork_test.cpp
+++ b/indra/newview/tests/llviewernetwork_test.cpp
@@ -391,7 +391,7 @@ namespace tut
                       std::string("https://minimal.long.name/helpers/"));
         ensure_equals("minimal grid login page",
                       LLGridManager::getInstance()->getLoginPage("minimal.long.name"),
-                      std::string("http://minimal.long.name/app/login/"));
+                      std::string("https://minimal.long.name/app/login/"));
 
     }