loader: Permit broader valid usage re: layers.

Author: rpavlik

src/loader/api_layer_interface.cpp

@@ -88,39 +88,32 @@ XrResult ApiLayerInterface::GetApiLayerProperties(const std::string& openxr_comm
     }
 
     manifest_count = static_cast<uint32_t>(manifest_files.size());
+    if (nullptr == outgoing_count) {
+        LoaderLogger::LogErrorMessage("xrEnumerateInstanceExtensionProperties",
+                                      "VUID-xrEnumerateApiLayerProperties-propertyCountOutput-parameter: null propertyCountOutput");
+        return XR_ERROR_VALIDATION_FAILURE;
+    }
+
+    *outgoing_count = manifest_count;
     if (0 == incoming_count) {
-        if (nullptr == outgoing_count) {
-            return XR_ERROR_VALIDATION_FAILURE;
-        }
-        *outgoing_count = manifest_count;
-    } else if (nullptr != api_layer_properties) {
-        if (incoming_count < manifest_count && nullptr != api_layer_properties) {
-            LoaderLogger::LogErrorMessage(
-                "xrEnumerateInstanceExtensionProperties",
-                "VUID-xrEnumerateApiLayerProperties-propertyCapacityInput-parameter: insufficient space in array");
-            *outgoing_count = manifest_count;
-            return XR_ERROR_SIZE_INSUFFICIENT;
-        }
+        // capacity check only
+        return XR_SUCCESS;
+    }
+    if (nullptr == api_layer_properties) {
+        // incoming_count is not 0 BUT the api_layer_properties is NULL
+        LoaderLogger::LogErrorMessage("xrEnumerateInstanceExtensionProperties",
+                                      "VUID-xrEnumerateApiLayerProperties-properties-parameter: non-zero capacity but null array");
+        return XR_ERROR_VALIDATION_FAILURE;
+    }
+    if (incoming_count < manifest_count) {
+        LoaderLogger::LogErrorMessage(
+            "xrEnumerateInstanceExtensionProperties",
+            "VUID-xrEnumerateApiLayerProperties-propertyCapacityInput-parameter: insufficient space in array");
+        return XR_ERROR_SIZE_INSUFFICIENT;
+    }
 
-        uint32_t prop = 0;
-        bool properties_valid = true;
-        for (; prop < incoming_count && prop < manifest_count; ++prop) {
-            if (nullptr != api_layer_properties[prop].next) {
-                LoaderLogger::LogErrorMessage(openxr_command, "VUID-XrApiLayerProperties-next-next: expected NULL");
-                properties_valid = false;
-            }
-            if (properties_valid) {
-                api_layer_properties[prop] = manifest_files[prop]->GetApiLayerProperties();
-            }
-        }
-        if (!properties_valid) {
-            LoaderLogger::LogErrorMessage(openxr_command,
-                                          "VUID-xrEnumerateApiLayerProperties-properties-parameter: invalid properties");
-            return XR_ERROR_VALIDATION_FAILURE;
-        }
-        if (nullptr != outgoing_count) {
-            *outgoing_count = prop;
-        }
+    for (uint32_t prop = 0; prop < incoming_count && prop < manifest_count; ++prop) {
+        manifest_files[prop]->PopulateApiLayerProperties(api_layer_properties[prop]);
     }
     return XR_SUCCESS;
 }

src/loader/manifest_file.cpp

@@ -773,10 +773,7 @@ void ApiLayerManifestFile::CreateIfValid(ManifestFileType type, const std::strin
     manifest_files.back()->ParseCommon(layer_root_node);
 }
 
-XrApiLayerProperties ApiLayerManifestFile::GetApiLayerProperties() const {
-    XrApiLayerProperties props = {};
-    props.type = XR_TYPE_API_LAYER_PROPERTIES;
-    props.next = nullptr;
+void ApiLayerManifestFile::PopulateApiLayerProperties(XrApiLayerProperties &props) const {
     props.layerVersion = _implementation_version;
     props.specVersion = XR_MAKE_VERSION(_api_version.major, _api_version.minor, _api_version.patch);
     strncpy(props.layerName, _layer_name.c_str(), XR_MAX_API_LAYER_NAME_SIZE - 1);
@@ -787,7 +784,6 @@ XrApiLayerProperties ApiLayerManifestFile::GetApiLayerProperties() const {
     if (_description.size() >= XR_MAX_API_LAYER_DESCRIPTION_SIZE - 1) {
         props.description[XR_MAX_API_LAYER_DESCRIPTION_SIZE - 1] = '\0';
     }
-    return props;
 }
 
 // Find all layer manifest files in the appropriate search paths/registries for the given type.

src/loader/manifest_file.hpp

@@ -98,7 +98,7 @@ class ApiLayerManifestFile : public ManifestFile {
     static XrResult FindManifestFiles(ManifestFileType type, std::vector<std::unique_ptr<ApiLayerManifestFile>> &manifest_files);
 
     const std::string &LayerName() const { return _layer_name; }
-    XrApiLayerProperties GetApiLayerProperties() const;
+    void PopulateApiLayerProperties(XrApiLayerProperties &props) const;
 
    private:
     ApiLayerManifestFile(ManifestFileType type, const std::string &filename, const std::string &layer_name,