Remove custom MakeUnique. (#1080)

Since Amber was updated past c++14 we can now use `std::make_unique`
instead of the local `amber::MakeUnique`. This Cl updates all uses and
removes the custom version.

Author: dj2

.gitignore

@@ -35,3 +35,4 @@ cmake-build-*/
 
 ### The 'compile_commands' file can be generated at root
 compile_commands.json
+.DS_Store

android_sample/jni/amber_script.cc

@@ -14,8 +14,6 @@
 
 #include "amber_script.h"
 
-#include "src/make_unique.h"
-
 namespace amber {
 namespace android {
 namespace {
@@ -28,33 +26,39 @@ const char kShaderExtension[] = ".spv";
 bool IsEndedWith(const std::string& path, const std::string& end) {
   const size_t path_size = path.size();
   const size_t end_size = end.size();
-  if (path_size < end_size)
+  if (path_size < end_size) {
     return false;
+  }
 
   return path.compare(path_size - end_size, end_size, end) == 0;
 }
 
 bool IsStartedWith(const std::string& path, const std::string& start) {
   const size_t path_size = path.size();
   const size_t start_size = start.size();
-  if (path_size < start_size)
+  if (path_size < start_size) {
     return false;
+  }
 
   return path.compare(0, start_size, start) == 0;
 }
 
 std::string GetShaderID(const std::string& shader_name) {
   size_t spv_extension_pos = shader_name.find_last_of('.');
-  if (spv_extension_pos == std::string::npos)
+  if (spv_extension_pos == std::string::npos) {
     return std::string();
+  }
 
   size_t shader_id_pos =
       shader_name.find_last_of('.', spv_extension_pos - 1UL) + 1UL;
-  if (shader_id_pos == std::string::npos)
+  if (shader_id_pos == std::string::npos) {
     return std::string();
+  }
 
-  if (shader_id_pos >= spv_extension_pos || shader_name.size() <= shader_id_pos)
+  if (shader_id_pos >= spv_extension_pos ||
+      shader_name.size() <= shader_id_pos) {
     return std::string();
+  }
 
   return shader_name.substr(shader_id_pos, spv_extension_pos - shader_id_pos);
 }
@@ -67,27 +71,32 @@ AmberScriptLoader::~AmberScriptLoader() = default;
 
 Result AmberScriptLoader::LoadAllScriptsFromAsset() {
   auto shader_names = FindAllScriptsAndReturnShaderNames();
-  if (script_info_.empty())
+  if (script_info_.empty()) {
     return Result("No Amber script found");
+  }
 
   for (auto& info : script_info_) {
     info.script_content = ReadScript(info.asset_name);
-    if (info.script_content.empty())
+    if (info.script_content.empty()) {
       return Result(info.asset_name + ":\n\tEmpty Amber script");
+    }
   }
 
   for (auto& info : script_info_) {
     for (const auto& shader : shader_names) {
-      if (!IsStartedWith(shader, info.asset_name + kShaderNameSignature))
+      if (!IsStartedWith(shader, info.asset_name + kShaderNameSignature)) {
         continue;
+      }
 
       auto shader_content = ReadSpvShader(shader);
-      if (shader_content.empty())
+      if (shader_content.empty()) {
         return Result(shader + ":\n\tEmpty shader");
+      }
 
       auto id = GetShaderID(shader);
-      if (id.empty())
+      if (id.empty()) {
         return Result(shader + ":\n\tFail to get shader ID");
+      }
 
       info.shader_map[id] = shader_content;
     }
@@ -110,8 +119,9 @@ AmberScriptLoader::FindAllScriptsAndReturnShaderNames() {
       script_info_.back().asset_name = file_name_in_string;
     }
 
-    if (IsEndedWith(file_name_in_string, kShaderExtension))
+    if (IsEndedWith(file_name_in_string, kShaderExtension)) {
       shaders.push_back(file_name_in_string);
+    }
   }
   AAssetDir_close(asset);
 
@@ -123,8 +133,9 @@ std::vector<uint8_t> AmberScriptLoader::ReadContent(
   auto asset_path = kAmberDir + asset_name;
   AAsset* asset = AAssetManager_open(app_context_->activity->assetManager,
                                      asset_path.c_str(), AASSET_MODE_BUFFER);
-  if (!asset)
+  if (!asset) {
     return std::vector<uint8_t>();
+  }
 
   size_t size_in_bytes = AAsset_getLength(asset);
 
@@ -145,8 +156,9 @@ std::string AmberScriptLoader::ReadScript(const std::string& script_name) {
 std::vector<uint32_t> AmberScriptLoader::ReadSpvShader(
     const std::string& shader_name) {
   auto content = ReadContent(shader_name);
-  if (content.size() % sizeof(uint32_t) != 0)
+  if (content.size() % sizeof(uint32_t) != 0) {
     return std::vector<uint32_t>();
+  }
 
   return std::vector<uint32_t>(
       reinterpret_cast<uint32_t*>(content.data()),

android_sample/jni/main.cc

@@ -66,8 +66,9 @@ void amber_sample_main(android_app* app) {
 
   if (!failures.empty()) {
     LOGE("\nSummary of Failures:");
-    for (const auto& failure : failures)
+    for (const auto& failure : failures) {
       LOGE("%s", failure.c_str());
+    }
   }
   LOGE("\nsummary: %u pass, %u fail",
        static_cast<uint32_t>(script_info.size() - failures.size()),
@@ -105,7 +106,7 @@ void android_main(struct android_app* app) {
     }
 
     if (result >= 0 && source != nullptr) {
-        source->process(app, source);
+      source->process(app, source);
     }
   }
 }

samples/amber.cc

@@ -34,7 +34,6 @@
 #include "samples/ppm.h"
 #include "samples/timestamp.h"
 #include "src/build-versions.h"
-#include "src/make_unique.h"
 
 #if AMBER_ENABLE_SPIRV_TOOLS
 #include "spirv-tools/libspirv.hpp"
@@ -533,7 +532,7 @@ int main(int argc, const char** argv) {
     delegate.SetScriptPath(file.substr(0, file.find_last_of("/\\") + 1));
 
     amber::Amber am(&delegate);
-    std::unique_ptr<amber::Recipe> recipe = amber::MakeUnique<amber::Recipe>();
+    std::unique_ptr<amber::Recipe> recipe = std::make_unique<amber::Recipe>();
 
     result = am.Parse(data, recipe.get());
     if (!result.IsSuccess()) {

samples/config_helper.cc

@@ -19,8 +19,6 @@
 #include <string>
 #include <vector>
 
-#include "src/make_unique.h"
-
 #if AMBER_ENGINE_DAWN
 #include "samples/config_helper_dawn.h"
 #endif  // AMBER_ENGINE_DAWN
@@ -51,14 +49,14 @@ amber::Result ConfigHelper::CreateConfig(
   switch (engine) {
     case amber::kEngineTypeVulkan:
 #if AMBER_ENGINE_VULKAN
-      impl_ = amber::MakeUnique<ConfigHelperVulkan>();
+      impl_ = std::make_unique<ConfigHelperVulkan>();
       break;
 #else
       return amber::Result("Unable to create engine config for Vulkan");
 #endif  // AMBER_ENGINE_VULKAN
     case amber::kEngineTypeDawn:
 #if AMBER_ENGINE_DAWN
-      impl_ = amber::MakeUnique<ConfigHelperDawn>();
+      impl_ = std::make_unique<ConfigHelperDawn>();
       break;
 #else
       return amber::Result("Unable to create engine config for Dawn");

samples/ppm_test.cc

@@ -21,7 +21,6 @@
 
 #include "amber/result.h"
 #include "gtest/gtest.h"
-#include "src/make_unique.h"
 
 namespace amber {
 namespace {

src/amber.cc

@@ -24,7 +24,6 @@
 #include "src/descriptor_set_and_binding_parser.h"
 #include "src/engine.h"
 #include "src/executor.h"
-#include "src/make_unique.h"
 #include "src/parser.h"
 #include "src/vkscript/parser.h"
 
@@ -96,9 +95,9 @@ amber::Result Amber::Parse(const std::string& input, amber::Recipe* recipe) {
 
   std::unique_ptr<Parser> parser;
   if (input.substr(0, 7) == "#!amber") {
-    parser = MakeUnique<amberscript::Parser>(GetDelegate());
+    parser = std::make_unique<amberscript::Parser>(GetDelegate());
   } else {
-    parser = MakeUnique<vkscript::Parser>(GetDelegate());
+    parser = std::make_unique<vkscript::Parser>(GetDelegate());
   }
 
   Result r = parser->Parse(input);