loader_test: major update redux

Author: daveh-lunarg

src/api_layers/CMakeLists.txt

@@ -31,10 +31,15 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/api_layer_platform_defines.h ${CMAKE_
 
 # Basics for api_dump API Layer
 
+if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
+    set(LAYER_LIB_NAME "XrApiLayer_api_dump")
+else()
+    set(LAYER_LIB_NAME "libXrApiLayer_api_dump")
+endif()
 gen_xr_layer_json(
     ${CMAKE_CURRENT_BINARY_DIR}/XrApiLayer_api_dump.json
     LUNARG_api_dump
-    libXrApiLayer_api_dump${CMAKE_SHARED_MODULE_SUFFIX}
+    ${LAYER_LIB_NAME}${CMAKE_SHARED_MODULE_SUFFIX}
     1
     "API Layer to record api calls as they occur"
     ""
@@ -96,10 +101,15 @@ endif()
 
 # Basics for core_validation API Layer
 
+if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
+    set(LAYER_LIB_NAME "XrApiLayer_core_validation")
+else()
+    set(LAYER_LIB_NAME "libXrApiLayer_core_validation")
+endif()
 gen_xr_layer_json(
     ${CMAKE_CURRENT_BINARY_DIR}/XrApiLayer_core_validation.json
     LUNARG_core_validation
-    libXrApiLayer_core_validation${CMAKE_SHARED_MODULE_SUFFIX}
+    ${LAYER_LIB_NAME}${CMAKE_SHARED_MODULE_SUFFIX}
     1
     "API Layer to perform validation of api calls and parameters as they occur"
     ""

src/api_layers/api_dump.cpp

@@ -15,6 +15,7 @@
 // limitations under the License.
 //
 // Author: Mark Young <marky@lunarg.com>
+// Author: Dave Houlton <daveh@lunarg.com>
 //
 
 #include "hex_and_handles.h"
@@ -469,62 +470,50 @@ XrResult ApiDumpLayerXrCreateApiLayerInstance(const XrInstanceCreateInfo *info,
         contents.emplace_back("XrResult", "xrCreateInstance", "");
         contents.emplace_back("const XrInstanceCreateInfo*", "info", PointerToHexString(info));
         if (nullptr != info) {
-            std::string prefix = "info->";
+            std::string info_prefix = "info->";
             contents.emplace_back("XrStructureType", "info->type", std::to_string(info->type));
-            std::string next_prefix = prefix;
+            std::string next_prefix = info_prefix;
             next_prefix += "next";
             // Decode the next chain if it exists
             if (!ApiDumpDecodeNextChain(nullptr, info->next, next_prefix, contents)) {
                 throw std::invalid_argument("Invalid Operation");
             }
-            std::string flags_prefix = prefix;
+            std::string flags_prefix = info_prefix;
             flags_prefix += "createFlags";
             contents.emplace_back("XrInstanceCreateFlags", flags_prefix, std::to_string(info->createFlags));
-            std::string applicationinfo_prefix = prefix;
+            std::string applicationinfo_prefix = info_prefix;
             applicationinfo_prefix += "applicationInfo";
             if (!ApiDumpOutputXrStruct(nullptr, &info->applicationInfo, applicationinfo_prefix, "XrApplicationInfo", true,
                                        contents)) {
                 throw std::invalid_argument("Invalid Operation");
             }
-            std::string enabledapilayercount_prefix = prefix;
+            std::string enabledapilayercount_prefix = info_prefix;
             enabledapilayercount_prefix += "enabledApiLayerCount";
             std::ostringstream oss_enabledApiLayerCount;
             oss_enabledApiLayerCount << "0x" << std::hex << (info->enabledApiLayerCount);
             contents.emplace_back("uint32_t", enabledapilayercount_prefix, oss_enabledApiLayerCount.str());
-            std::string enabledapilayernames_prefix = prefix;
+            std::string enabledapilayernames_prefix = info_prefix;
             enabledapilayernames_prefix += "enabledApiLayerNames";
             std::ostringstream oss_enabledApiLayerNames_array;
             oss_enabledApiLayerNames_array << "0x" << std::hex << (info->enabledApiLayerNames);
             contents.emplace_back("const char* const*", enabledapilayernames_prefix, oss_enabledApiLayerNames_array.str());
-            for (uint32_t info_enabledapilayernames_inc = 0; info_enabledapilayernames_inc < info->enabledApiLayerCount;
-                 ++info_enabledapilayernames_inc) {
-                std::string enabledapilayernames_array_prefix = enabledapilayernames_prefix;
-                enabledapilayernames_array_prefix += "[";
-                enabledapilayernames_array_prefix += std::to_string(info_enabledapilayernames_inc);
-                enabledapilayernames_array_prefix += "]";
-                std::ostringstream oss_enabledApiLayerNames;
-                oss_enabledApiLayerNames << "0x" << std::hex << (*info->enabledApiLayerNames[info_enabledapilayernames_inc]);
-                contents.emplace_back("const char* const*", enabledapilayernames_array_prefix, oss_enabledApiLayerNames.str());
+            for (uint32_t i = 0; i < info->enabledApiLayerCount; ++i) {
+                std::string prefix = enabledapilayernames_prefix + "[" + std::to_string(i) + "]";
+                contents.emplace_back("const char* const*", prefix, info->enabledApiLayerNames[i]);
             }
-            std::string enabledextensioncount_prefix = prefix;
+            std::string enabledextensioncount_prefix = info_prefix;
             enabledextensioncount_prefix += "enabledExtensionCount";
             std::ostringstream oss_enabledExtensionCount;
             oss_enabledExtensionCount << "0x" << std::hex << (info->enabledExtensionCount);
             contents.emplace_back("uint32_t", enabledextensioncount_prefix, oss_enabledExtensionCount.str());
-            std::string enabledextensionnames_prefix = prefix;
+            std::string enabledextensionnames_prefix = info_prefix;
             enabledextensionnames_prefix += "enabledExtensionNames";
             std::ostringstream oss_enabledExtensionNames_array;
             oss_enabledExtensionNames_array << "0x" << std::hex << (info->enabledExtensionNames);
             contents.emplace_back("const char* const*", enabledextensionnames_prefix, oss_enabledExtensionNames_array.str());
-            for (uint32_t info_enabledextensionnames_inc = 0; info_enabledextensionnames_inc < info->enabledExtensionCount;
-                 ++info_enabledextensionnames_inc) {
-                std::string enabledextensionnames_array_prefix = enabledextensionnames_prefix;
-                enabledextensionnames_array_prefix += "[";
-                enabledextensionnames_array_prefix += std::to_string(info_enabledextensionnames_inc);
-                enabledextensionnames_array_prefix += "]";
-                std::ostringstream oss_enabledExtensionNames;
-                oss_enabledExtensionNames << "0x" << std::hex << (*info->enabledExtensionNames[info_enabledextensionnames_inc]);
-                contents.emplace_back("const char* const*", enabledextensionnames_array_prefix, oss_enabledExtensionNames.str());
+            for (uint32_t ii = 0; ii < info->enabledExtensionCount; ++ii) {
+                std::string prefix = enabledextensionnames_prefix + "[" + std::to_string(ii) + "]";
+                contents.emplace_back("const char* const*", prefix, info->enabledExtensionNames[ii]);
             }
         }
 

src/common/filesystem_utils.cpp

@@ -223,8 +223,12 @@ bool FileSysUtilsParsePathList(std::string& path_list, std::vector<std::string>&
 }
 
 bool FileSysUtilsFindFilesInPath(const std::string& path, std::vector<std::string>& files) {
+    // Append "\\*" to file name to list folder contents. This appears to contradict the
+    // MS documentation and example code, but verified empirically 
+    std::string starred_path = path + DIRECTORY_SYMBOL + "*";
+
     WIN32_FIND_DATAW file_data;
-    HANDLE file_handle = FindFirstFileW(utf8_to_wide(path).c_str(), &file_data);
+    HANDLE file_handle = FindFirstFileW(utf8_to_wide(starred_path).c_str(), &file_data);
     if (file_handle != INVALID_HANDLE_VALUE) {
         do {
             if (!(file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {

src/common/object_info.cpp

@@ -16,6 +16,7 @@
 // limitations under the License.
 //
 // Author: Mark Young <marky@lunarg.com>, Ryan Pavlik <ryan.pavlik@collabora.com>
+// Author: Dave Houlton <daveh@lunarg.com>
 //
 
 #include "object_info.h"
@@ -32,6 +33,8 @@
 #include <string>
 #include <vector>
 
+#include "memory.h"
+
 std::string XrSdkLogObjectInfo::ToString() const {
     std::ostringstream oss;
     oss << Uint64ToHexString(handle);
@@ -238,44 +241,45 @@ NamesAndLabels DebugUtilsData::PopulateNamesAndLabels(std::vector<XrSdkLogObject
     return {objects, labels};
 }
 
-AugmentedCallbackData DebugUtilsData::AugmentCallbackData(
-    const XrDebugUtilsMessengerCallbackDataEXT& provided_callback_data) const {
-    AugmentedCallbackData ret{provided_callback_data};
-    if (object_info_.Empty() || provided_callback_data.objectCount == 0) {
-        return ret;
+void DebugUtilsData::WrapCallbackData(AugmentedCallbackData* aug_data,
+                                      const XrDebugUtilsMessengerCallbackDataEXT* callback_data) const {
+    // If there's nothing to add, just retun the original data as the augmented copy
+    aug_data->exported_data = callback_data;
+    if (object_info_.Empty() || callback_data->objectCount == 0) {
+        return;
     }
-    bool obj_name_found = false;
-    for (uint32_t obj = 0; obj < provided_callback_data.objectCount; ++obj) {
-        auto& current_obj = provided_callback_data.objects[obj];
-        if (!obj_name_found) {
-            auto lookup = object_info_.LookUpStoredObjectInfo(current_obj.objectHandle, current_obj.objectType);
-            if (lookup != nullptr) {
-                obj_name_found = true;
-            }
-        }
 
-        // If this is a session, see if there are any labels associated with it for us to add
-        // to the callback content.
+    // Inspect each of the callback objects
+    bool name_found = false;
+    for (uint32_t obj = 0; obj < callback_data->objectCount; ++obj) {
+        auto& current_obj = callback_data->objects[obj];
+        name_found |= (nullptr != object_info_.LookUpStoredObjectInfo(current_obj.objectHandle, current_obj.objectType));
+
+        // If this is a session, record any labels associated with it
         if (XR_OBJECT_TYPE_SESSION == current_obj.objectType) {
             XrSession session = TreatIntegerAsHandle<XrSession>(current_obj.objectHandle);
-            LookUpSessionLabels(session, ret.labels);
+            LookUpSessionLabels(session, aug_data->labels);
         }
     }
 
-    if (!obj_name_found && ret.labels.empty()) {
-        // nothing to add to the data
-        return ret;
+    // If we found nothing to add, return the original data
+    if (!name_found && aug_data->labels.empty()) {
+        return;
     }
 
-    // If a name or a label has been found, we should update it in a new version of the callback data
-    ret.new_objects.assign(provided_callback_data.objects, provided_callback_data.objects + provided_callback_data.objectCount);
+    // Found additional data - modify an internal copy and return that as the exported data
+    memcpy(&aug_data->modified_data, callback_data, sizeof(XrDebugUtilsMessengerCallbackDataEXT));
+    aug_data->new_objects.assign(callback_data->objects, callback_data->objects + callback_data->objectCount);
 
-    for (auto& obj : ret.new_objects) {
+    // Record (overwrite) the names of all incoming objects provided in our internal list
+    for (auto& obj : aug_data->new_objects) {
         object_info_.LookUpObjectName(obj);
     }
-    ret.temporary_callback_data.objects = ret.new_objects.data();
-    ret.temporary_callback_data.sessionLabelCount = static_cast<uint32_t>(ret.labels.size());
-    ret.temporary_callback_data.sessionLabels = ret.labels.empty() ? nullptr : ret.labels.data();
-    ret.callback_data_to_use = &ret.temporary_callback_data;
-    return ret;
+
+    // Update local copy & point export to it
+    aug_data->modified_data.objects = aug_data->new_objects.data();
+    aug_data->modified_data.sessionLabelCount = static_cast<uint32_t>(aug_data->labels.size());
+    aug_data->modified_data.sessionLabels = aug_data->labels.empty() ? nullptr : aug_data->labels.data();
+    aug_data->exported_data = &aug_data->modified_data;
+    return;
 }

src/common/object_info.h

@@ -181,14 +181,12 @@ struct NamesAndLabels {
 };
 
 struct AugmentedCallbackData {
-    explicit AugmentedCallbackData(const XrDebugUtilsMessengerCallbackDataEXT& data_to_use)
-        : temporary_callback_data(data_to_use), callback_data_to_use(&data_to_use) {}
     std::vector<XrDebugUtilsLabelEXT> labels;
-    XrDebugUtilsMessengerCallbackDataEXT temporary_callback_data;
     std::vector<XrDebugUtilsObjectNameInfoEXT> new_objects;
-
-    const XrDebugUtilsMessengerCallbackDataEXT* callback_data_to_use;
+    XrDebugUtilsMessengerCallbackDataEXT modified_data;
+    const XrDebugUtilsMessengerCallbackDataEXT* exported_data;
 };
+
 /// Tracks all the data (handle names and session labels) required to fully augment XR_EXT_debug_utils-related calls.
 class DebugUtilsData {
    public:
@@ -225,7 +223,8 @@ class DebugUtilsData {
     /// Given the collection of objects, populate their names and list of labels
     NamesAndLabels PopulateNamesAndLabels(std::vector<XrSdkLogObjectInfo> objects) const;
 
-    AugmentedCallbackData AugmentCallbackData(const XrDebugUtilsMessengerCallbackDataEXT& provided_callback_data) const;
+    void WrapCallbackData(AugmentedCallbackData* aug_data,
+                          const XrDebugUtilsMessengerCallbackDataEXT* provided_callback_data) const;
 
    private:
     void RemoveIndividualLabel(XrSdkSessionLabelList& label_vec);

src/common/platform_utils.hpp

@@ -1,6 +1,6 @@
 // Copyright (c) 2017-2019 The Khronos Group Inc.
-// Copyright (c) 2017 Valve Corporation
-// Copyright (c) 2017 LunarG, Inc.
+// Copyright (c) 2017-2019 Valve Corporation
+// Copyright (c) 2017-2019 LunarG, Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -15,6 +15,7 @@
 // limitations under the License.
 //
 // Author: Mark Young <marky@lunarg.com>
+// Author: Dave Houlton <daveh@lunarg.com>
 //
 
 #pragma once
@@ -28,6 +29,20 @@
 #include <iostream>
 #endif
 
+// OpenXR paths and registry key locations
+#define OPENXR_RELATIVE_PATH "openxr/"
+#define OPENXR_IMPLICIT_API_LAYER_RELATIVE_PATH "/api_layers/implicit.d"
+#define OPENXR_EXPLICIT_API_LAYER_RELATIVE_PATH "/api_layers/explicit.d"
+#ifdef XR_OS_WINDOWS
+#define OPENXR_REGISTRY_LOCATION "SOFTWARE\\Khronos\\OpenXR\\"
+#define OPENXR_IMPLICIT_API_LAYER_REGISTRY_LOCATION "\\ApiLayers\\Implicit"
+#define OPENXR_EXPLICIT_API_LAYER_REGISTRY_LOCATION "\\ApiLayers\\Explicit"
+#endif
+
+// OpenXR Loader environment variables of interest
+#define OPENXR_RUNTIME_JSON_ENV_VAR "XR_RUNTIME_JSON"
+#define OPENXR_API_LAYER_PATH_ENV_VAR "XR_API_LAYER_PATH"
+
 // This is a CMake generated file with #defines for any functions/includes
 // that it found present and build-time configuration.
 // If you don't have this file, on non-Windows you'll need to define