viewer_manifest is run twice by CMakeLists.txt: once with --actions=copy and
once with the default actions copy and package. The fact that we (try to) move
the Mac viewer executable both times has confused things on a number of
occasions. Currently it's bollixing our attempt to run dsymutil on the
executable so we can package up the Mac symbols for both codeticket and
BugSplat.

Introduce DarwinManifest.is_rearranging() that tests whether either "package"
or "unpacked" is in self.args["actions"], echoing an earlier test. Make
several things conditional on that, notably moving the executable.

This is a separate step from generating and posting BugSplat symbols, since
BugSplat needs the executable along with the symbols, and we don't need to
consume that space in a symbols tarball.

Move Mac BugSplat symbol generation logic to CMake land, the same general area
where Breakpad symbols are generated. Add stanzas to pack up the usual tarball
for Windows and Mac.

Remove the build.sh test that suppressed uploading the symbols tarball for
BugSplat builds.

Define the CMake cache variable, with empty string as its default.

Make build.sh pass the BUGSPLAT_DB environment variable as a CMake
command-line variable assignment.

Change CMake 'if (DEFINED ENV{BUGSPLAT_DB})' to plain 'if (BUGSPLAT_DB)'.

Make CMake pass new --bugsplat switch to every one of SIX different
invocations of viewer_manifest.py.

Give llmanifest.main() function an argument to allow supplementing the base
set of command-line switches with additional application-specific switches.

In viewer_manifest.py, define new --bugsplat command-line switch and pass to
llmanifest.main(). Instead of consulting os.environ['BUGSPLAT_DB'], consult
self.args['bugsplat'].

viewer_manifest.py had LLManifest.prefix() calls starting with '..' (or
os.pardir, same thing) which failed with new prefix() calling conventions.
Explicitly starting with os.path.join(self.args['build'], os.pardir, etc.)
where applicable works much better.

Turns out that having multiple (source, build, artwork) prefix stacks isn't
such a good idea after all. Many of our LLManifest.path() directives use
wildcards -- and if _any files_ match the specified wildcard from a prefix
stack other than what you had in mind, viewer_manifest will silently,
cheerfully do the Wrong Thing.

There is a good reason why all existing LLManifest.prefix() calls exclusively
used src= and/or dst= instead of build=.

The way prefix("path_fragment") or prefix(src="path_fragment") has always
worked is that unless you explicitly specify dst="", it adds "path_fragment"
to the source AND dest prefix stacks!

The most recent refactoring of viewer_manifest.py failed to copy CEF because
it involved prefix(src="../some lengthy path fragment") -- forgetting to
specify dst="" -- which added "../some lengthy path fragment" to the dest
prefix stack -- which put it outside the viewer install staging area
altogether.

Having been bitten too many times by forgetting to add prefix(dst=""), we
remove the necessity. The prefix() src=, build= and dst= prefix stacks are now
completely independent. Add src_dst= keyword argument for when you DO want to
add the same path fragment to both the source and dest prefix stacks.
("Explicit is better than implicit.")

Change all existing calls accordingly.

Now that the build prefix stack no longer tracks the src prefix stack, we were
failing to pick up some things from the build area because NOBODY ever used
build=, relying entirely on src= to point both to stuff in the source tree and
stuff in the build tree. Try to use build= appropriately.

If that proves too confusing, we might eliminate the separate build and
artwork (!) prefix stacks entirely, requiring callers to reset the src stack
explicitly when switching back and forth.

Set our CMake 'product' variable to VIEWER_CHANNEL. This probably has far-
reaching implications, but it seems the expedient way to keep everything self-
consistent. Use ${product} in the DARWIN VIEWER_EXE_GLOBS used for Breakpad
symbol dumping instead of hardcoding 'Second Life'.

The Breakpad symbol dumping stanza was enclosed in nested (but not indented)
conditions. To these we add another condition: don't bother if we're using
BugSplat. Unify all three into a single horrendous outermost expression.

Fix the MACOSX_BUNDLE_INFO_STRING, and hence CFBundleGetInfoString, to
VIEWER_CHANNEL as well.

Our CMake MACOSX_BUNDLE_SHORT_VERSION_STRING was never used before -- we were
erroneously using MACOSX_BUNDLE_LONG_VERSION_STRING in the Info-SecondLife.plist
template even for CFBundleShortVersionString. Looks like a classic copy/paste
error. Fix that; also use four-part version number instead of three-part.

With those two changes, we shouldn't need to patch the top-level Info.plist in
viewer_manifest.py any more.

viewer_manifest.py still needs to move the viewer executable(s) to the
embedded viewer app bundle, but it no longer needs to rename the real
executable to the channel name since we've already dealt with that in CMake
land. This lets us unify the code that picks the biggest of those executables
in the first and second viewer_manifest.py runs.

This requires fixing CFBundleExecutable as well.

On TeamCity, set BUGSPLAT_DB from build-secrets.

Use the presence of $BUGSPLAT_DB, rather than a new CMake BUGSPLAT option, to
control whether CMake searches for BugSplat -- and passes LL_BUGSPLAT into C++.

When BUGSPLAT_DB is present, make viewer_manifest.py set "BugSplat DB" in
build_data.json, and "BugsplatServerURL" in Mac Info.plist.

Make llappviewerwin32.cpp read "BugSplat DB" from build_data.json.

Add placeholders for Mac hooks to suppress BugSplat prompt and send
SecondLife.log.

MAINT-8119 Fix. A change elsewhere in the viewer_manifest.py script that copies files into the right place after a build impacted the fragment of code that copies over the VLC runtime files (Libvlc.dll, libvlccore.dll and the VLC plugins dir) and they never made it to the right place. This change restores that copy

A change elsewhere in the viewer_manifest.py script that copies files into the right place after a build impacted the fragment of code that copies over the VLC runtime files (Libvlc.dll, libvlccore.dll and the VLC plugins dir) and they never made it to the right place. This change restores that copy

This evidently makes all the difference as to whether the app is considered
launchable.

Specifically, Second Life.app is now mostly just a wrapper. Its Contents/
Resources contains nested Launcher.app (the VMP) and Viewer.app (the viewer
itself). Most of what used to be in the top-level Second Life.app has been
relocated to the embedded Viewer.app. VMP stuff has of course been extracted
to Launcher.app. The top-level Second Life.app executable is now a tiny script
that runs Launcher.app. This structure permits different icons and different
Dock flyover text for the launcher and the viewer, hopefully ameliorating a
certain amount of user confusion about the dual icons.

This requires a corresponding VMP change: on macOS, the VMP must now find both
its resources and the viewer executable by walking up from Launcher.app and
down again into its sibling Viewer.app.

Since Dock flyover text is determined by the embedded app names, allow Product
to change these at will. That means we should be able to tweak exactly one
variable assignment to change either of those embedded app names, without
having to chase down other references scattered throughout the source repo.

For that reason, create top-level trampoline SL_Launcher script dynamically:
it must reference the launcher app by name. That means we must also perform
(the equivalent of) chmod +x on that generated script.

The one mystery surrounding this restructuring is that without a top-level
Frameworks symlink pointing to the embedded Viewer.app's Frameworks directory
(where CEF lives), CEF refuses to start: no splash screen, no MoP. Perhaps we
can fix that someday.

Use Python's bundled plistlib to generate Info.plist files for the embedded
applications.

Reorganize stray code stanzas to try to help the structure of the code more or
less resemble the structure of the desired result.

Add ViewerManifest.relpath() method to determine the relative path from a
specified base to the target path. If base omitted, assumes get_dst_prefix()
-- handy for creating symlinks. Determining exactly the right number of
os.pardir instances to concatenate into the relative pathname for a symlink
(or an install_name_tool stamp) was tedious, fragile and unobvious, difficult
to desk-check. Using relpath() should make all that more robust.

Migrate symlinkf() from free function to ViewerManifest method, refactoring
into _symlinkf_prep_dst() and _symlinkf(), adding relsymlinkf(). This lets us
add convenience features such as prepending get_dst_prefix() to the dest (the
place where we want to create the symlink), defaulting dest to the basename of
target and ensuring that the parent of that dest already exists -- as with
LLManifest.path(). Moreover, since it makes no sense whatsoever to create an
absolute symlink to some path on the build machine, relsymlinkf() creates
every symlink relative to dirname(dest). That, in turn, lets us eliminate a
certain amount of boilerplate around existing calls. (Also, since we now
ensure the parent directory exists, scrap the logic to diagnose "nonexistent
parent directory.")

Make llmanifest.LLManifest.run_command() not pass shell=True to subprocess,
thereby permitting (requiring) the list form rather than the string form.
Change all existing calls to list form. This makes calls more readable, for
two reasons. First, many of the arguments are taken from script variables;
these can simply be dropped into the list instead of indirecting through
string interpolation. Second, it eliminates the need to manually escape
individual arguments, since subprocess promises to honor the distinction
between list elements.

Also fix LLManifest.put_in_file() to ensure the containing directory exists.

Consolidate some viewer_manifest.py redundancy, e.g. copying the same set of
ten DLLs from either of two directories depending on Release vs. Debug.

The LLManifest.copy_action() method ensures that the destination directory for
any file copy exists before trying to copy the file, specifically so we don't
have to clutter the business logic with tests and explicit directory creation.
Remove redundant os.makedirs() stanzas.

Differentiate between 32/64 bit windows builds for build systewm (BugsSplat enforces specifc names that vary across bitness)

Now that LLManifest.prefix() supports use as a context manager:

    with self.prefix(...):
        ...

convert existing calls to that form.

This was an interesting exercise because it surfaced at least two places where
the indentation did not match the self.prefix() nesting, plus another place
where existing code was undented without a self.end_prefix() call. (That last
was an uncaught logic bug.) This underscores the value of using a SINGLE
consistent, idiomatic mechanism to limit the scope of each self.prefix() call.

To support that, enhance path_optional() to accept wildcards and return the
expanded filenames.

* do not redirect stderr to stdout
* catch errors generated in platform specific code and display them more nicely
* run_command no longer captures output (only used in one place;
  replaced that with direct use of subprocess)