Remove some asserts, use return Results (#260)

5 files changed, 222 insertions, 289 deletions

diff --git a/samples/amber.cc b/samples/amber.cc
index fc69f44..fb85e90 100644
--- a/samples/amber.cc
+++ b/samples/amber.cc
@@ -240,12 +240,20 @@ int main(int argc, const char** argv) {
   }
 
   sample::ConfigHelper config_helper;
-  auto config = config_helper.CreateConfig(
+  std::unique_ptr<amber::EngineConfig> config;
+
+  amber::Result r = config_helper.CreateConfig(
       amber_options.engine,
       std::vector<std::string>(required_features.begin(),
                                required_features.end()),
       std::vector<std::string>(required_extensions.begin(),
-                               required_extensions.end()));
+                               required_extensions.end()),
+      &config);
+
+  if (!r.IsSuccess()) {
+    std::cout << r.Error() << std::endl;
+    return 1;
+  }
 
   amber_options.config = config.get();
 
diff --git a/samples/config_helper.cc b/samples/config_helper.cc
index 9487210..406cf1f 100644
--- a/samples/config_helper.cc
+++ b/samples/config_helper.cc
@@ -15,7 +15,6 @@
 #include "samples/config_helper.h"
 
 #include <algorithm>
-#include <cassert>
 #include <set>
 #include <string>
 #include <vector>
@@ -34,24 +33,27 @@ ConfigHelper::ConfigHelper() = default;
 
 ConfigHelper::~ConfigHelper() = default;
 
-std::unique_ptr<amber::EngineConfig> ConfigHelper::CreateConfig(
+amber::Result ConfigHelper::CreateConfig(
     amber::EngineType engine,
     const std::vector<std::string>& required_features,
-    const std::vector<std::string>& required_extensions) {
+    const std::vector<std::string>& required_extensions,
+    std::unique_ptr<amber::EngineConfig>* config) {
   if (engine == amber::kEngineTypeDawn)
-    return nullptr;
+    return amber::Result("Unable to create engine config for Dawn");
 
 #if AMBER_ENGINE_VULKAN
   impl_ = amber::MakeUnique<ConfigHelperVulkan>();
 #endif  // AMBER_ENGINE_VULKAN
-  return impl_ ? impl_->CreateConfig(required_features, required_extensions)
-               : nullptr;
+  if (!impl_)
+    return amber::Result("Unable to create config helper");
+
+  return impl_->CreateConfig(required_features, required_extensions, config);
 }
 
-void ConfigHelper::Shutdown() {
+amber::Result ConfigHelper::Shutdown() {
   if (!impl_)
-    return;
-  impl_->Shutdown();
+    return {};
+  return impl_->Shutdown();
 }
 
 }  // namespace sample
diff --git a/samples/config_helper.h b/samples/config_helper.h
index 444d443..3c74892 100644
--- a/samples/config_helper.h
+++ b/samples/config_helper.h
@@ -32,12 +32,13 @@ class ConfigHelperImpl {
   // Create instance and device and return them as amber::EngineConfig.
   // |required_features| and |required_extensions| contain lists of
   // required features and required extensions, respectively.
-  virtual std::unique_ptr<amber::EngineConfig> CreateConfig(
+  virtual amber::Result CreateConfig(
       const std::vector<std::string>& required_features,
-      const std::vector<std::string>& required_extensions) = 0;
+      const std::vector<std::string>& required_extensions,
+      std::unique_ptr<amber::EngineConfig>* config) = 0;
 
   // Destroy instance and device.
-  virtual void Shutdown() = 0;
+  virtual amber::Result Shutdown() = 0;
 };
 
 // Wrapper of ConfigHelperImpl.
@@ -51,13 +52,14 @@ class ConfigHelper {
   // required features and required extensions, respectively. |engine|
   // indicates whether the caller required VulkanEngineConfig or
   // DawnEngineConfig.
-  std::unique_ptr<amber::EngineConfig> CreateConfig(
+  amber::Result CreateConfig(
       amber::EngineType engine,
       const std::vector<std::string>& required_features,
-      const std::vector<std::string>& required_extensions);
+      const std::vector<std::string>& required_extensions,
+      std::unique_ptr<amber::EngineConfig>* config);
 
   // Destroy instance and device.
-  void Shutdown();
+  amber::Result Shutdown();
 
  private:
   std::unique_ptr<ConfigHelperImpl> impl_;
diff --git a/samples/config_helper_vulkan.cc b/samples/config_helper_vulkan.cc
index f439e98..68ef667 100644
--- a/samples/config_helper_vulkan.cc
+++ b/samples/config_helper_vulkan.cc
@@ -16,7 +16,6 @@
 
 #include <vulkan/vulkan.h>
 #include <algorithm>
-#include <cassert>
 #include <cstring>
 #include <set>
 
@@ -69,236 +68,125 @@ VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(VkDebugReportFlagsEXT flag,
 
 // Convert required features given as a string array to
 // VkPhysicalDeviceFeatures.
-VkPhysicalDeviceFeatures NamesToVulkanFeatures(
-    const std::vector<std::string>& required_feature_names) {
-  VkPhysicalDeviceFeatures required_vulkan_features = {};
+amber::Result NamesToVulkanFeatures(
+    const std::vector<std::string>& required_feature_names,
+    VkPhysicalDeviceFeatures* features) {
   for (const auto& name : required_feature_names) {
     if (name == "robustBufferAccess") {
-      required_vulkan_features.robustBufferAccess = VK_TRUE;
-      continue;
-    }
-    if (name == "fullDrawIndexUint32") {
-      required_vulkan_features.fullDrawIndexUint32 = VK_TRUE;
-      continue;
-    }
-    if (name == "imageCubeArray") {
-      required_vulkan_features.imageCubeArray = VK_TRUE;
-      continue;
-    }
-    if (name == "independentBlend") {
-      required_vulkan_features.independentBlend = VK_TRUE;
-      continue;
-    }
-    if (name == "geometryShader") {
-      required_vulkan_features.geometryShader = VK_TRUE;
-      continue;
-    }
-    if (name == "tessellationShader") {
-      required_vulkan_features.tessellationShader = VK_TRUE;
-      continue;
-    }
-    if (name == "sampleRateShading") {
-      required_vulkan_features.sampleRateShading = VK_TRUE;
-      continue;
-    }
-    if (name == "dualSrcBlend") {
-      required_vulkan_features.dualSrcBlend = VK_TRUE;
-      continue;
-    }
-    if (name == "logicOp") {
-      required_vulkan_features.logicOp = VK_TRUE;
-      continue;
-    }
-    if (name == "multiDrawIndirect") {
-      required_vulkan_features.multiDrawIndirect = VK_TRUE;
-      continue;
-    }
-    if (name == "drawIndirectFirstInstance") {
-      required_vulkan_features.drawIndirectFirstInstance = VK_TRUE;
-      continue;
-    }
-    if (name == "depthClamp") {
-      required_vulkan_features.depthClamp = VK_TRUE;
-      continue;
-    }
-    if (name == "depthBiasClamp") {
-      required_vulkan_features.depthBiasClamp = VK_TRUE;
-      continue;
-    }
-    if (name == "fillModeNonSolid") {
-      required_vulkan_features.fillModeNonSolid = VK_TRUE;
-      continue;
-    }
-    if (name == "depthBounds") {
-      required_vulkan_features.depthBounds = VK_TRUE;
-      continue;
-    }
-    if (name == "wideLines") {
-      required_vulkan_features.wideLines = VK_TRUE;
-      continue;
-    }
-    if (name == "largePoints") {
-      required_vulkan_features.largePoints = VK_TRUE;
-      continue;
-    }
-    if (name == "alphaToOne") {
-      required_vulkan_features.alphaToOne = VK_TRUE;
-      continue;
-    }
-    if (name == "multiViewport") {
-      required_vulkan_features.multiViewport = VK_TRUE;
-      continue;
-    }
-    if (name == "samplerAnisotropy") {
-      required_vulkan_features.samplerAnisotropy = VK_TRUE;
-      continue;
-    }
-    if (name == "textureCompressionETC2") {
-      required_vulkan_features.textureCompressionETC2 = VK_TRUE;
-      continue;
-    }
-    if (name == "textureCompressionASTC_LDR") {
-      required_vulkan_features.textureCompressionASTC_LDR = VK_TRUE;
-      continue;
-    }
-    if (name == "textureCompressionBC") {
-      required_vulkan_features.textureCompressionBC = VK_TRUE;
-      continue;
-    }
-    if (name == "occlusionQueryPrecise") {
-      required_vulkan_features.occlusionQueryPrecise = VK_TRUE;
-      continue;
-    }
-    if (name == "pipelineStatisticsQuery") {
-      required_vulkan_features.pipelineStatisticsQuery = VK_TRUE;
-      continue;
-    }
-    if (name == "vertexPipelineStoresAndAtomics") {
-      required_vulkan_features.vertexPipelineStoresAndAtomics = VK_TRUE;
-      continue;
-    }
-    if (name == "fragmentStoresAndAtomics") {
-      required_vulkan_features.fragmentStoresAndAtomics = VK_TRUE;
-      continue;
-    }
-    if (name == "shaderTessellationAndGeometryPointSize") {
-      required_vulkan_features.shaderTessellationAndGeometryPointSize = VK_TRUE;
-      continue;
-    }
-    if (name == "shaderImageGatherExtended") {
-      required_vulkan_features.shaderImageGatherExtended = VK_TRUE;
-      continue;
-    }
-    if (name == "shaderStorageImageExtendedFormats") {
-      required_vulkan_features.shaderStorageImageExtendedFormats = VK_TRUE;
-      continue;
-    }
-    if (name == "shaderStorageImageMultisample") {
-      required_vulkan_features.shaderStorageImageMultisample = VK_TRUE;
-      continue;
-    }
-    if (name == "shaderStorageImageReadWithoutFormat") {
-      required_vulkan_features.shaderStorageImageReadWithoutFormat = VK_TRUE;
-      continue;
-    }
-    if (name == "shaderStorageImageWriteWithoutFormat") {
-      required_vulkan_features.shaderStorageImageWriteWithoutFormat = VK_TRUE;
-      continue;
-    }
-    if (name == "shaderUniformBufferArrayDynamicIndexing") {
-      required_vulkan_features.shaderUniformBufferArrayDynamicIndexing =
-          VK_TRUE;
-      continue;
-    }
-    if (name == "shaderSampledImageArrayDynamicIndexing") {
-      required_vulkan_features.shaderSampledImageArrayDynamicIndexing = VK_TRUE;
-      continue;
-    }
-    if (name == "shaderStorageBufferArrayDynamicIndexing") {
-      required_vulkan_features.shaderStorageBufferArrayDynamicIndexing =
-          VK_TRUE;
-      continue;
-    }
-    if (name == "shaderStorageImageArrayDynamicIndexing") {
-      required_vulkan_features.shaderStorageImageArrayDynamicIndexing = VK_TRUE;
-      continue;
-    }
-    if (name == "shaderClipDistance") {
-      required_vulkan_features.shaderClipDistance = VK_TRUE;
-      continue;
-    }
-    if (name == "shaderCullDistance") {
-      required_vulkan_features.shaderCullDistance = VK_TRUE;
-      continue;
-    }
-    if (name == "shaderFloat64") {
-      required_vulkan_features.shaderFloat64 = VK_TRUE;
-      continue;
-    }
-    if (name == "shaderInt64") {
-      required_vulkan_features.shaderInt64 = VK_TRUE;
-      continue;
-    }
-    if (name == "shaderInt16") {
-      required_vulkan_features.shaderInt16 = VK_TRUE;
-      continue;
-    }
-    if (name == "shaderResourceResidency") {
-      required_vulkan_features.shaderResourceResidency = VK_TRUE;
-      continue;
-    }
-    if (name == "shaderResourceMinLod") {
-      required_vulkan_features.shaderResourceMinLod = VK_TRUE;
-      continue;
-    }
-    if (name == "sparseBinding") {
-      required_vulkan_features.sparseBinding = VK_TRUE;
-      continue;
-    }
-    if (name == "sparseResidencyBuffer") {
-      required_vulkan_features.sparseResidencyBuffer = VK_TRUE;
-      continue;
-    }
-    if (name == "sparseResidencyImage2D") {
-      required_vulkan_features.sparseResidencyImage2D = VK_TRUE;
-      continue;
-    }
-    if (name == "sparseResidencyImage3D") {
-      required_vulkan_features.sparseResidencyImage3D = VK_TRUE;
-      continue;
-    }
-    if (name == "sparseResidency2Samples") {
-      required_vulkan_features.sparseResidency2Samples = VK_TRUE;
-      continue;
-    }
-    if (name == "sparseResidency4Samples") {
-      required_vulkan_features.sparseResidency4Samples = VK_TRUE;
-      continue;
-    }
-    if (name == "sparseResidency8Samples") {
-      required_vulkan_features.sparseResidency8Samples = VK_TRUE;
-      continue;
-    }
-    if (name == "sparseResidency16Samples") {
-      required_vulkan_features.sparseResidency16Samples = VK_TRUE;
-      continue;
-    }
-    if (name == "sparseResidencyAliased") {
-      required_vulkan_features.sparseResidencyAliased = VK_TRUE;
-      continue;
-    }
-    if (name == "variableMultisampleRate") {
-      required_vulkan_features.variableMultisampleRate = VK_TRUE;
-      continue;
-    }
-    if (name == "inheritedQueries") {
-      required_vulkan_features.inheritedQueries = VK_TRUE;
-      continue;
-    }
-
-    assert(false && "Sample: Unknown Vulkan feature");
-  }
-  return required_vulkan_features;
+      features->robustBufferAccess = VK_TRUE;
+    } else if (name == "fullDrawIndexUint32") {
+      features->fullDrawIndexUint32 = VK_TRUE;
+    } else if (name == "imageCubeArray") {
+      features->imageCubeArray = VK_TRUE;
+    } else if (name == "independentBlend") {
+      features->independentBlend = VK_TRUE;
+    } else if (name == "geometryShader") {
+      features->geometryShader = VK_TRUE;
+    } else if (name == "tessellationShader") {
+      features->tessellationShader = VK_TRUE;
+    } else if (name == "sampleRateShading") {
+      features->sampleRateShading = VK_TRUE;
+    } else if (name == "dualSrcBlend") {
+      features->dualSrcBlend = VK_TRUE;
+    } else if (name == "logicOp") {
+      features->logicOp = VK_TRUE;
+    } else if (name == "multiDrawIndirect") {
+      features->multiDrawIndirect = VK_TRUE;
+    } else if (name == "drawIndirectFirstInstance") {
+      features->drawIndirectFirstInstance = VK_TRUE;
+    } else if (name == "depthClamp") {
+      features->depthClamp = VK_TRUE;
+    } else if (name == "depthBiasClamp") {
+      features->depthBiasClamp = VK_TRUE;
+    } else if (name == "fillModeNonSolid") {
+      features->fillModeNonSolid = VK_TRUE;
+    } else if (name == "depthBounds") {
+      features->depthBounds = VK_TRUE;
+    } else if (name == "wideLines") {
+      features->wideLines = VK_TRUE;
+    } else if (name == "largePoints") {
+      features->largePoints = VK_TRUE;
+    } else if (name == "alphaToOne") {
+      features->alphaToOne = VK_TRUE;
+    } else if (name == "multiViewport") {
+      features->multiViewport = VK_TRUE;
+    } else if (name == "samplerAnisotropy") {
+      features->samplerAnisotropy = VK_TRUE;
+    } else if (name == "textureCompressionETC2") {
+      features->textureCompressionETC2 = VK_TRUE;
+    } else if (name == "textureCompressionASTC_LDR") {
+      features->textureCompressionASTC_LDR = VK_TRUE;
+    } else if (name == "textureCompressionBC") {
+      features->textureCompressionBC = VK_TRUE;
+    } else if (name == "occlusionQueryPrecise") {
+      features->occlusionQueryPrecise = VK_TRUE;
+    } else if (name == "pipelineStatisticsQuery") {
+      features->pipelineStatisticsQuery = VK_TRUE;
+    } else if (name == "vertexPipelineStoresAndAtomics") {
+      features->vertexPipelineStoresAndAtomics = VK_TRUE;
+    } else if (name == "fragmentStoresAndAtomics") {
+      features->fragmentStoresAndAtomics = VK_TRUE;
+    } else if (name == "shaderTessellationAndGeometryPointSize") {
+      features->shaderTessellationAndGeometryPointSize = VK_TRUE;
+    } else if (name == "shaderImageGatherExtended") {
+      features->shaderImageGatherExtended = VK_TRUE;
+    } else if (name == "shaderStorageImageExtendedFormats") {
+      features->shaderStorageImageExtendedFormats = VK_TRUE;
+    } else if (name == "shaderStorageImageMultisample") {
+      features->shaderStorageImageMultisample = VK_TRUE;
+    } else if (name == "shaderStorageImageReadWithoutFormat") {
+      features->shaderStorageImageReadWithoutFormat = VK_TRUE;
+    } else if (name == "shaderStorageImageWriteWithoutFormat") {
+      features->shaderStorageImageWriteWithoutFormat = VK_TRUE;
+    } else if (name == "shaderUniformBufferArrayDynamicIndexing") {
+      features->shaderUniformBufferArrayDynamicIndexing = VK_TRUE;
+    } else if (name == "shaderSampledImageArrayDynamicIndexing") {
+      features->shaderSampledImageArrayDynamicIndexing = VK_TRUE;
+    } else if (name == "shaderStorageBufferArrayDynamicIndexing") {
+      features->shaderStorageBufferArrayDynamicIndexing = VK_TRUE;
+    } else if (name == "shaderStorageImageArrayDynamicIndexing") {
+      features->shaderStorageImageArrayDynamicIndexing = VK_TRUE;
+    } else if (name == "shaderClipDistance") {
+      features->shaderClipDistance = VK_TRUE;
+    } else if (name == "shaderCullDistance") {
+      features->shaderCullDistance = VK_TRUE;
+    } else if (name == "shaderFloat64") {
+      features->shaderFloat64 = VK_TRUE;
+    } else if (name == "shaderInt64") {
+      features->shaderInt64 = VK_TRUE;
+    } else if (name == "shaderInt16") {
+      features->shaderInt16 = VK_TRUE;
+    } else if (name == "shaderResourceResidency") {
+      features->shaderResourceResidency = VK_TRUE;
+    } else if (name == "shaderResourceMinLod") {
+      features->shaderResourceMinLod = VK_TRUE;
+    } else if (name == "sparseBinding") {
+      features->sparseBinding = VK_TRUE;
+    } else if (name == "sparseResidencyBuffer") {
+      features->sparseResidencyBuffer = VK_TRUE;
+    } else if (name == "sparseResidencyImage2D") {
+      features->sparseResidencyImage2D = VK_TRUE;
+    } else if (name == "sparseResidencyImage3D") {
+      features->sparseResidencyImage3D = VK_TRUE;
+    } else if (name == "sparseResidency2Samples") {
+      features->sparseResidency2Samples = VK_TRUE;
+    } else if (name == "sparseResidency4Samples") {
+      features->sparseResidency4Samples = VK_TRUE;
+    } else if (name == "sparseResidency8Samples") {
+      features->sparseResidency8Samples = VK_TRUE;
+    } else if (name == "sparseResidency16Samples") {
+      features->sparseResidency16Samples = VK_TRUE;
+    } else if (name == "sparseResidencyAliased") {
+      features->sparseResidencyAliased = VK_TRUE;
+    } else if (name == "variableMultisampleRate") {
+      features->variableMultisampleRate = VK_TRUE;
+    } else if (name == "inheritedQueries") {
+      features->inheritedQueries = VK_TRUE;
+    } else {
+      return amber::Result("Sample: Unknown Vulkan feature");
+    }
+  }
+  return {};
 }
 
 bool AreAllValidationLayersSupported() {
@@ -658,18 +546,16 @@ ConfigHelperVulkan::ConfigHelperVulkan() = default;
 
 ConfigHelperVulkan::~ConfigHelperVulkan() = default;
 
-void ConfigHelperVulkan::CreateVulkanInstance() {
+amber::Result ConfigHelperVulkan::CreateVulkanInstance() {
   VkApplicationInfo app_info = {};
   app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
   app_info.apiVersion = VK_MAKE_VERSION(1, 0, 0);
 
-  if (!AreAllValidationLayersSupported()) {
-    assert(false && "Sample: not all validation layers are supported");
-  }
-
+  if (!AreAllValidationLayersSupported())
+    return amber::Result("Sample: not all validation layers are supported");
   if (!AreAllValidationExtensionsSupported()) {
-    assert(false &&
-           "Sample: extensions of validation layers are not supported");
+    return amber::Result(
+        "Sample: extensions of validation layers are not supported");
   }
 
   VkInstanceCreateInfo instance_info = {};
@@ -680,11 +566,14 @@ void ConfigHelperVulkan::CreateVulkanInstance() {
   instance_info.enabledExtensionCount = 1U;
   instance_info.ppEnabledExtensionNames = &kExtensionForValidationLayer;
 
-  assert(vkCreateInstance(&instance_info, nullptr, &vulkan_instance_) ==
-         VK_SUCCESS);
+  if (vkCreateInstance(&instance_info, nullptr, &vulkan_instance_) !=
+      VK_SUCCESS) {
+    return amber::Result("Unable to create vulkan instance");
+  }
+  return {};
 }
 
-void ConfigHelperVulkan::CreateDebugReportCallback() {
+amber::Result ConfigHelperVulkan::CreateDebugReportCallback() {
   VkDebugReportCallbackCreateInfoEXT info = {};
   info.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
   info.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT;
@@ -695,25 +584,31 @@ void ConfigHelperVulkan::CreateDebugReportCallback() {
           vkGetInstanceProcAddr(vulkan_instance_,
                                 "vkCreateDebugReportCallbackEXT"));
   if (!vkCreateDebugReportCallbackEXT)
-    assert(false && "Sample: vkCreateDebugReportCallbackEXT is nullptr");
+    return amber::Result("Sample: vkCreateDebugReportCallbackEXT is nullptr");
 
   if (vkCreateDebugReportCallbackEXT(vulkan_instance_, &info, nullptr,
                                      &vulkan_callback_) != VK_SUCCESS) {
-    assert(false && "Sample: vkCreateDebugReportCallbackEXT fail");
+    return amber::Result("Sample: vkCreateDebugReportCallbackEXT fail");
   }
+  return {};
 }
 
-void ConfigHelperVulkan::ChooseVulkanPhysicalDevice(
+amber::Result ConfigHelperVulkan::ChooseVulkanPhysicalDevice(
     const VkPhysicalDeviceFeatures& required_features,
     const std::vector<std::string>& required_extensions) {
   uint32_t count;
   std::vector<VkPhysicalDevice> physical_devices;
 
-  assert(vkEnumeratePhysicalDevices(vulkan_instance_, &count, nullptr) ==
-         VK_SUCCESS);
+  if (vkEnumeratePhysicalDevices(vulkan_instance_, &count, nullptr) !=
+      VK_SUCCESS) {
+    return amber::Result("Unable to enumerate physical devices");
+  }
+
   physical_devices.resize(count);
-  assert(vkEnumeratePhysicalDevices(vulkan_instance_, &count,
-                                    physical_devices.data()) == VK_SUCCESS);
+  if (vkEnumeratePhysicalDevices(vulkan_instance_, &count,
+                                 physical_devices.data()) != VK_SUCCESS) {
+    return amber::Result("Unable to enumerate physical devices");
+  }
 
   for (uint32_t i = 0; i < count; ++i) {
     vkGetPhysicalDeviceFeatures(physical_devices[i], &available_features_);
@@ -731,14 +626,14 @@ void ConfigHelperVulkan::ChooseVulkanPhysicalDevice(
     vulkan_queue_family_index_ = ChooseQueueFamilyIndex(physical_devices[i]);
     if (vulkan_queue_family_index_ != std::numeric_limits<uint32_t>::max()) {
       vulkan_physical_device_ = physical_devices[i];
-      return;
+      return {};
     }
   }
 
-  assert(false && "Vulkan::No physical device supports Vulkan");
+  return amber::Result("Vulkan::No physical device supports Vulkan");
 }
 
-void ConfigHelperVulkan::CreateVulkanDevice(
+amber::Result ConfigHelperVulkan::CreateVulkanDevice(
     const VkPhysicalDeviceFeatures& required_features,
     const std::vector<std::string>& required_extensions) {
   VkDeviceQueueCreateInfo queue_info = {};
@@ -764,26 +659,46 @@ void ConfigHelperVulkan::CreateVulkanDevice(
       static_cast<uint32_t>(required_extensions_in_char.size());
   info.ppEnabledExtensionNames = required_extensions_in_char.data();
 
-  assert(vkCreateDevice(vulkan_physical_device_, &info, nullptr,
-                        &vulkan_device_) == VK_SUCCESS);
+  if (vkCreateDevice(vulkan_physical_device_, &info, nullptr,
+                     &vulkan_device_) != VK_SUCCESS) {
+    return amber::Result("Unable to create vulkan device");
+  }
+  return {};
 }
 
-std::unique_ptr<amber::EngineConfig> ConfigHelperVulkan::CreateConfig(
+amber::Result ConfigHelperVulkan::CreateConfig(
     const std::vector<std::string>& required_features,
-    const std::vector<std::string>& required_extensions) {
-  auto required_vulkan_features = NamesToVulkanFeatures(required_features);
+    const std::vector<std::string>& required_extensions,
+    std::unique_ptr<amber::EngineConfig>* cfg_holder) {
+  VkPhysicalDeviceFeatures required_vulkan_features = {};
+  amber::Result r =
+      NamesToVulkanFeatures(required_features, &required_vulkan_features);
+  if (!r.IsSuccess())
+    return r;
+
+  r = CreateVulkanInstance();
+  if (!r.IsSuccess())
+    return r;
+
+  r = CreateDebugReportCallback();
+  if (!r.IsSuccess())
+    return r;
+
+  r = ChooseVulkanPhysicalDevice(required_vulkan_features, required_extensions);
+  if (!r.IsSuccess())
+    return r;
+
+  r = CreateVulkanDevice(required_vulkan_features, required_extensions);
+  if (!r.IsSuccess())
+    return r;
 
-  CreateVulkanInstance();
-  CreateDebugReportCallback();
-  ChooseVulkanPhysicalDevice(required_vulkan_features, required_extensions);
-  CreateVulkanDevice(required_vulkan_features, required_extensions);
   vkGetDeviceQueue(vulkan_device_, vulkan_queue_family_index_, 0,
                    &vulkan_queue_);
 
-  std::unique_ptr<amber::EngineConfig> cfg_holder =
+  *cfg_holder =
       std::unique_ptr<amber::EngineConfig>(new amber::VulkanEngineConfig());
   amber::VulkanEngineConfig* config =
-      static_cast<amber::VulkanEngineConfig*>(cfg_holder.get());
+      static_cast<amber::VulkanEngineConfig*>(cfg_holder->get());
   config->physical_device = vulkan_physical_device_;
   config->available_features = available_features_;
   config->available_extensions = available_extensions_;
@@ -792,10 +707,11 @@ std::unique_ptr<amber::EngineConfig> ConfigHelperVulkan::CreateConfig(
   config->queue = vulkan_queue_;
   config->device = vulkan_device_;
   config->vkGetInstanceProcAddr = vkGetInstanceProcAddr;
-  return cfg_holder;
+
+  return {};
 }
 
-void ConfigHelperVulkan::Shutdown() {
+amber::Result ConfigHelperVulkan::Shutdown() {
   if (vulkan_device_ != VK_NULL_HANDLE)
     vkDestroyDevice(vulkan_device_, nullptr);
 
@@ -803,14 +719,17 @@ void ConfigHelperVulkan::Shutdown() {
       reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(
           vkGetInstanceProcAddr(vulkan_instance_,
                                 "vkDestroyDebugReportCallbackEXT"));
-  assert(vkDestroyDebugReportCallbackEXT &&
-         "Sample: vkDestroyDebugReportCallbackEXT is nullptr");
+  if (!vkDestroyDebugReportCallbackEXT)
+    return amber::Result("Sample: vkDestroyDebugReportCallbackEXT is nullptr");
+
   if (vulkan_callback_ != VK_NULL_HANDLE)
     vkDestroyDebugReportCallbackEXT(vulkan_instance_, vulkan_callback_,
                                     nullptr);
 
   if (vulkan_instance_ != VK_NULL_HANDLE)
     vkDestroyInstance(vulkan_instance_, nullptr);
+
+  return {};
 }
 
 }  // namespace sample
diff --git a/samples/config_helper_vulkan.h b/samples/config_helper_vulkan.h
index fe8aea5..e51a05e 100644
--- a/samples/config_helper_vulkan.h
+++ b/samples/config_helper_vulkan.h
@@ -38,31 +38,33 @@ class ConfigHelperVulkan : public ConfigHelperImpl {
   // amber::VulkanEngineConfig. Required Vulkan device features and
   // extensions are given in |required_features| and
   // |required_extensions|, respectively.
-  std::unique_ptr<amber::EngineConfig> CreateConfig(
+  amber::Result CreateConfig(
       const std::vector<std::string>& required_features,
-      const std::vector<std::string>& required_extensions) override;
+      const std::vector<std::string>& required_extensions,
+      std::unique_ptr<amber::EngineConfig>* config) override;
 
   // Destroy Vulkan instance and device.
-  void Shutdown() override;
+  amber::Result Shutdown() override;
 
  private:
   // Create Vulkan instance.
-  void CreateVulkanInstance();
+  amber::Result CreateVulkanInstance();
 
   // Create |vulkan_callback_| that reports validation layer errors
   // via debugCallback() function in config_helper_vulkan.cc.
-  void CreateDebugReportCallback();
+  amber::Result CreateDebugReportCallback();
 
   // Choose Vulkan physical device that supports both
   // |required_features| and |required_extensions|.
-  void ChooseVulkanPhysicalDevice(
+  amber::Result ChooseVulkanPhysicalDevice(
       const VkPhysicalDeviceFeatures& required_features,
       const std::vector<std::string>& required_extensions);
 
   // Create Vulkan logical device that enables both
   // |required_features| and |required_extensions|.
-  void CreateVulkanDevice(const VkPhysicalDeviceFeatures& required_features,
-                          const std::vector<std::string>& required_extensions);
+  amber::Result CreateVulkanDevice(
+      const VkPhysicalDeviceFeatures& required_features,
+      const std::vector<std::string>& required_extensions);
 
   VkInstance vulkan_instance_ = VK_NULL_HANDLE;
   VkDebugReportCallbackEXT vulkan_callback_ = VK_NULL_HANDLE;