| Age | Commit message (Collapse) | Author |
|---|
|
|
|
LLWinDebug, though an LLSingleton, had (and required explicit calls to)
special init() and cleanup() methods. Kitty Barnett points out that the
cleanup() method was actually being called after LLSingletonBase::deleteAll(),
requiring resurrection of the deleted LLWinDebug, which sometimes led to
crashes. (Resurrecting deleted LLSingletons is always suspect.)
Change LLWinDebug::init() and cleanup() to the conventional initSingleton()
and cleanupSingleton() methods. This eliminates the need to make special
method calls at all. In particular, cleanupSingleton() will be called by the
existing LLSingletonBase::cleanupAll() call near viewer shutdown.
We retain the early LLWinDebug::instance() call, which implicitly initializes
the LLWinDebug instance, because evidently we want that initialized early. But
we no longer require a separate init() call.
|
|
The comment indicates that calling LLSingletonBase::deleteAll() is optional
because the LLSingleton machinery implicitly calls that during final
static-object cleanup. That is no longer true.
|
|
The recent LLSingleton work added a hook that would run during the C++
runtime's final destruction of static objects. When the LAST LLSingleton in
any module was destroyed, its destructor would call
LLSingletonBase::deleteAll(). That mechanism was intended to permit an
application consuming LLSingletons to skip making an explicit deleteAll()
call, knowing that all instantiated LLSingleton instances would eventually be
cleaned up anyway.
However -- experience proves that kicking off deleteAll() processing during
the C++ runtime's final cleanup is too late. Too much has already been
destroyed. That call tends to cause more shutdown crashes than it resolves.
This commit deletes that whole mechanism. Going forward, if you want to clean
up LLSingleton instances, you must explicitly call
LLSingletonBase::deleteAll() during the application lifetime. If you don't,
LLSingleton instances will simply be leaked -- which might be okay,
considering the application is terminating anyway.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
studio
|
|
here: https://bitbucket.org/rider_linden/doduo-viewer/commits/4f39500cb46e879dbb732e6547cc66f3ba39959e?at=default
|
|
useful during testing SLPlugin changes. Not shipped with release versions of viewer
|
|
|
|
was (a) scary, (b) didn't work on 64 bit and (c) likely the cause of a lot of anti-virus false positives
|
|
working ' appears.
|
|
|
|
|
|
|
|
preference (pull in new version of Dullahan with improved support)
|
|
|
|
browser. (Surprisingly large amount of changes and new version of Dullahan to support this fix)
|
|
|
|
- this change also fixes MAINT-5365 Windows viewer uninstall icon is system default not SL logo
|
|
|
|
|
|
|
|
The previous LLSafeHandle<T> implementation declares a static data member of
the template class but provides no (generic) definition, relying on particular
specializations to provide the definition. The data member is a function
pointer, which is called in one of the methods to produce a pointer to a
"null" T instance: that is, a dummy instance to be dereferenced in case the
wrapped T* is null.
Xcode 8.3's version of clang is bothered by the call, in a generic method,
through this (usually) uninitialized pointer. It happens that the only
specializations of LLSafeHandle do both provide definitions. I don't know
whether that's formally valid C++03 or not; but I agree with the compiler: I
don't like it.
Instead of declaring a public static function pointer which each
specialization is required to define, add a protected static method to the
template class. This protected static method simply returns a pointer to a
function-static T instance. This is functionally similar to a static
LLPointer<T> set on demand (as in the two specializations), including lazy
instantiation.
Unlike the previous implementation, this approach prohibits a given
specialization from customizing the "null" instance function. Although there
exist reasonable ways to support that (e.g. a related traits template), I
decided not to complicate the LLSafeHandle implementation to make it more
generally useful. I don't really approve of LLSafeHandle, and don't want to
see it proliferate. It's not clear that unconditionally dereferencing
LLSafeHandle<T> is in any way better than conditionally dereferencing
LLPointer<T>. It doesn't even skip the runtime conditional test; it simply
obscures it. (There exist hints in the code that at one time it might have
immediately replaced any wrapped null pointer value with the pointer to the
"null" instance, obviating the test at dereference time, but this is not the
current functionality. Perhaps it was only ever wishful thinking.)
Remove the corresponding functions and static LLPointers from the two classes
that use LLSafeHandle.
|
|
|
|
containing object is in another region
|
|
|
|
When a 'family' code isn't recognized, for instance, report the family code.
That should at least clue us in to look up and add an entry for the relevant
family code.
|
|
|
|
|
|
moving
|
|
|
|
|
|
appears to be because two of the MS DLLs we ship with the 64 bit viewer are 32bit. Manually replacing them with their 64 bit equivalents allowed the viewer to start on Windows 8.1. The change forces the cmake file which copies the DLLs to look in C:\windows\SysWOW64 for 32 bit versions and C:\windows\system32 for 64 bit versions. (yes really).
|
|
IM. (Drake and Appurist convinced me my initial solution was non-optimal)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
unless visible
|
|
|
