From 698bf0846b7ebf3f399db0a1ff2e10ca5460eaa3 Mon Sep 17 00:00:00 2001 From: Martin Kustermann Date: Wed, 29 May 2024 10:16:28 +0000 Subject: [PATCH] [vm] Hoist `CStringUniquePtr` out of Utils`, add `CAllocUniquePtr` to simplify code Hoist `CStringUniquePtr` out of the `Utils` class as there is no reason it has to be nested inside a class - it just makes code more verbose. This simplifies code of the form std::unique_ptr a = { nullptr, std::free }; to CAllocUniquePtr a; TEST=ci Change-Id: Ice42c1b16dfa5b20b321c13fbe5b28b3918581cb Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/368425 Commit-Queue: Martin Kustermann Reviewed-by: Daco Harkes --- runtime/bin/dartdev_isolate.cc | 11 +++++------ runtime/bin/dartdev_isolate.h | 4 ++-- runtime/bin/dfe.h | 4 ++-- runtime/bin/exe_utils.cc | 10 ++++------ runtime/bin/exe_utils.h | 2 +- runtime/bin/file.h | 2 +- runtime/bin/file_fuchsia.cc | 6 +++--- runtime/bin/file_linux.cc | 6 +++--- runtime/bin/file_macos.cc | 6 +++--- runtime/bin/file_win.cc | 8 ++++---- runtime/bin/snapshot_utils.cc | 5 ++--- runtime/bin/utils_win.h | 8 ++++---- runtime/platform/utils.cc | 4 ---- runtime/platform/utils.h | 16 +++++++++++----- runtime/vm/compiler/backend/il_test.cc | 4 ++-- runtime/vm/compiler/backend/memory_copy_test.cc | 4 ++-- .../backend/redundancy_elimination_test.cc | 17 +++++++---------- .../compiler/write_barrier_elimination_test.cc | 5 ++--- runtime/vm/dart_api_impl_test.cc | 15 +++++---------- runtime/vm/flags.cc | 3 +-- runtime/vm/heap/heap_test.cc | 4 ++-- runtime/vm/isolate_reload_test.cc | 8 ++++---- runtime/vm/object.cc | 4 ++-- runtime/vm/object_test.cc | 5 ++--- runtime/vm/timeline.cc | 14 ++++++-------- runtime/vm/timeline.h | 6 +++--- 26 files changed, 83 insertions(+), 98 deletions(-) diff --git a/runtime/bin/dartdev_isolate.cc b/runtime/bin/dartdev_isolate.cc index 685196547f7..7116b7dad56 100644 --- a/runtime/bin/dartdev_isolate.cc +++ b/runtime/bin/dartdev_isolate.cc @@ -79,8 +79,7 @@ bool DartDevIsolate::ShouldParseCommand(const char* script_uri) { (strncmp(script_uri, "google3://", 10) != 0))); } -Utils::CStringUniquePtr DartDevIsolate::TryResolveArtifactPath( - const char* filename) { +CStringUniquePtr DartDevIsolate::TryResolveArtifactPath(const char* filename) { // |dir_prefix| includes the last path separator. auto dir_prefix = EXEUtils::GetDirectoryPrefixFromExeName(); @@ -88,7 +87,7 @@ Utils::CStringUniquePtr DartDevIsolate::TryResolveArtifactPath( char* snapshot_path = Utils::SCreate("%ssnapshots/%s", dir_prefix.get(), filename); if (File::Exists(nullptr, snapshot_path)) { - return Utils::CreateCStringUniquePtr(snapshot_path); + return CStringUniquePtr(snapshot_path); } free(snapshot_path); @@ -96,13 +95,13 @@ Utils::CStringUniquePtr DartDevIsolate::TryResolveArtifactPath( // directories. Try to use a snapshot from a previously built SDK. snapshot_path = Utils::SCreate("%s%s", dir_prefix.get(), filename); if (File::Exists(nullptr, snapshot_path)) { - return Utils::CreateCStringUniquePtr(snapshot_path); + return CStringUniquePtr(snapshot_path); } free(snapshot_path); - return Utils::CreateCStringUniquePtr(nullptr); + return CStringUniquePtr(nullptr); } -Utils::CStringUniquePtr DartDevIsolate::TryResolveDartDevSnapshotPath() { +CStringUniquePtr DartDevIsolate::TryResolveDartDevSnapshotPath() { return TryResolveArtifactPath("dartdev.dart.snapshot"); } diff --git a/runtime/bin/dartdev_isolate.h b/runtime/bin/dartdev_isolate.h index a5158f78285..79566c658f3 100644 --- a/runtime/bin/dartdev_isolate.h +++ b/runtime/bin/dartdev_isolate.h @@ -47,7 +47,7 @@ class DartDevIsolate { static bool should_run_dart_dev() { return should_run_dart_dev_; } // Attempts to find the path of the DartDev snapshot. - static Utils::CStringUniquePtr TryResolveDartDevSnapshotPath(); + static CStringUniquePtr TryResolveDartDevSnapshotPath(); // Starts a DartDev instance in a new isolate and runs it to completion. // @@ -93,7 +93,7 @@ class DartDevIsolate { }; private: - static Utils::CStringUniquePtr TryResolveArtifactPath(const char* filename); + static CStringUniquePtr TryResolveArtifactPath(const char* filename); static DartDevRunner runner_; static bool should_run_dart_dev_; diff --git a/runtime/bin/dfe.h b/runtime/bin/dfe.h index c5dd4ee88f9..9b0e4c55040 100644 --- a/runtime/bin/dfe.h +++ b/runtime/bin/dfe.h @@ -178,13 +178,13 @@ class KernelBlob { public: // Takes ownership over [uri] and [buffer]. KernelBlob(char* uri, uint8_t* buffer, intptr_t size) - : uri_(uri, std::free), buffer_(buffer, std::free), size_(size) {} + : uri_(uri), buffer_(buffer, std::free), size_(size) {} std::shared_ptr buffer() { return buffer_; } intptr_t size() const { return size_; } private: - Utils::CStringUniquePtr uri_; + CStringUniquePtr uri_; std::shared_ptr buffer_; const intptr_t size_; diff --git a/runtime/bin/exe_utils.cc b/runtime/bin/exe_utils.cc index 59bb32b9d34..3b8d6fa50e1 100644 --- a/runtime/bin/exe_utils.cc +++ b/runtime/bin/exe_utils.cc @@ -65,7 +65,7 @@ static const char* GetFileNameFromPath(const char* path) { return path; } -Utils::CStringUniquePtr EXEUtils::GetDirectoryPrefixFromExeName() { +CStringUniquePtr EXEUtils::GetDirectoryPrefixFromExeName() { const char* name = nullptr; const int kTargetSize = PATH_MAX; char target[kTargetSize]; @@ -87,8 +87,7 @@ Utils::CStringUniquePtr EXEUtils::GetDirectoryPrefixFromExeName() { // cwd is currently wherever we launched from, so set the cwd to the // directory of the symlink while we try and resolve it. If we don't // do this, we won't be able to properly resolve relative paths. - auto initial_dir_path = - Utils::CreateCStringUniquePtr(Directory::CurrentNoScope()); + CStringUniquePtr initial_dir_path(Directory::CurrentNoScope()); // We might run into symlinks of symlinks, so make sure we follow the // links all the way. See https://github.com/dart-lang/sdk/issues/41057 for // an example where this happens with brew on MacOS. @@ -98,7 +97,7 @@ Utils::CStringUniquePtr EXEUtils::GetDirectoryPrefixFromExeName() { name = File::LinkTarget(namespc, GetFileNameFromPath(name), target, kTargetSize); if (name == nullptr) { - return Utils::CreateCStringUniquePtr(Utils::StrDup("")); + return CStringUniquePtr(Utils::StrDup("")); } } while (File::GetType(namespc, name, false) == File::kIsLink); target_size = strlen(name); @@ -117,8 +116,7 @@ Utils::CStringUniquePtr EXEUtils::GetDirectoryPrefixFromExeName() { result = GetDirectoryFromPath(target, nullptr); } namespc->Release(); - return Utils::CreateCStringUniquePtr(result == nullptr ? Utils::StrDup("") - : result); + return CStringUniquePtr(result == nullptr ? Utils::StrDup("") : result); } #if !defined(DART_HOST_OS_WINDOWS) diff --git a/runtime/bin/exe_utils.h b/runtime/bin/exe_utils.h index e7ab8b6e5ca..1540cd53287 100644 --- a/runtime/bin/exe_utils.h +++ b/runtime/bin/exe_utils.h @@ -18,7 +18,7 @@ namespace bin { class EXEUtils { public: // Returns the path to the directory the current executable resides in. - static Utils::CStringUniquePtr GetDirectoryPrefixFromExeName(); + static CStringUniquePtr GetDirectoryPrefixFromExeName(); #if !defined(DART_HOST_OS_WINDOWS) // Loads a compact symbolization table from "$exepath.sym" that is used by the diff --git a/runtime/bin/file.h b/runtime/bin/file.h index 237d424fd9e..17493677367 100644 --- a/runtime/bin/file.h +++ b/runtime/bin/file.h @@ -230,7 +230,7 @@ class File : public ReferenceCounted { static File* OpenUri(Namespace* namespc, const char* uri, FileOpenMode mode); // Attempts to convert the given [uri] to a file path. - static Utils::CStringUniquePtr UriToPath(const char* uri); + static CStringUniquePtr UriToPath(const char* uri); // Create a file object for the specified stdio file descriptor // (stdin, stout or stderr). diff --git a/runtime/bin/file_fuchsia.cc b/runtime/bin/file_fuchsia.cc index 8661356e8b5..e54b564b4f8 100644 --- a/runtime/bin/file_fuchsia.cc +++ b/runtime/bin/file_fuchsia.cc @@ -253,15 +253,15 @@ File* File::Open(Namespace* namespc, const char* name, FileOpenMode mode) { return OpenFD(fd); } -Utils::CStringUniquePtr File::UriToPath(const char* uri) { +CStringUniquePtr File::UriToPath(const char* uri) { const char* path = (strlen(uri) >= 8 && strncmp(uri, "file:///", 8) == 0) ? uri + 7 : uri; UriDecoder uri_decoder(path); if (uri_decoder.decoded() == nullptr) { errno = EINVAL; - return Utils::CreateCStringUniquePtr(nullptr); + return CStringUniquePtr(nullptr); } - return Utils::CreateCStringUniquePtr(strdup(uri_decoder.decoded())); + return CStringUniquePtr(strdup(uri_decoder.decoded())); } File* File::OpenUri(Namespace* namespc, const char* uri, FileOpenMode mode) { diff --git a/runtime/bin/file_linux.cc b/runtime/bin/file_linux.cc index f080dd6f38d..6e907ed93c1 100644 --- a/runtime/bin/file_linux.cc +++ b/runtime/bin/file_linux.cc @@ -265,15 +265,15 @@ File* File::Open(Namespace* namespc, const char* name, FileOpenMode mode) { return OpenFD(fd); } -Utils::CStringUniquePtr File::UriToPath(const char* uri) { +CStringUniquePtr File::UriToPath(const char* uri) { const char* path = (strlen(uri) >= 8 && strncmp(uri, "file:///", 8) == 0) ? uri + 7 : uri; UriDecoder uri_decoder(path); if (uri_decoder.decoded() == nullptr) { errno = EINVAL; - return Utils::CreateCStringUniquePtr(nullptr); + return CStringUniquePtr(nullptr); } - return Utils::CreateCStringUniquePtr(strdup(uri_decoder.decoded())); + return CStringUniquePtr(strdup(uri_decoder.decoded())); } File* File::OpenUri(Namespace* namespc, const char* uri, FileOpenMode mode) { diff --git a/runtime/bin/file_macos.cc b/runtime/bin/file_macos.cc index 40cf176f06c..a469c9b244a 100644 --- a/runtime/bin/file_macos.cc +++ b/runtime/bin/file_macos.cc @@ -296,15 +296,15 @@ File* File::Open(Namespace* namespc, const char* name, FileOpenMode mode) { return new File(new FileHandle(fd)); } -Utils::CStringUniquePtr File::UriToPath(const char* uri) { +CStringUniquePtr File::UriToPath(const char* uri) { const char* path = (strlen(uri) >= 8 && strncmp(uri, "file:///", 8) == 0) ? uri + 7 : uri; UriDecoder uri_decoder(path); if (uri_decoder.decoded() == nullptr) { errno = EINVAL; - return Utils::CreateCStringUniquePtr(nullptr); + return CStringUniquePtr(nullptr); } - return Utils::CreateCStringUniquePtr(strdup(uri_decoder.decoded())); + return CStringUniquePtr(strdup(uri_decoder.decoded())); } File* File::OpenUri(Namespace* namespc, const char* uri, FileOpenMode mode) { diff --git a/runtime/bin/file_win.cc b/runtime/bin/file_win.cc index f4105032dd0..66cadbedf1b 100644 --- a/runtime/bin/file_win.cc +++ b/runtime/bin/file_win.cc @@ -447,23 +447,23 @@ File* File::Open(Namespace* namespc, const char* name, FileOpenMode mode) { return file; } -Utils::CStringUniquePtr File::UriToPath(const char* uri) { +CStringUniquePtr File::UriToPath(const char* uri) { UriDecoder uri_decoder(uri); if (uri_decoder.decoded() == nullptr) { SetLastError(ERROR_INVALID_NAME); - return Utils::CreateCStringUniquePtr(nullptr); + return CStringUniquePtr(nullptr); } const auto uri_w = Utf8ToWideChar(uri_decoder.decoded()); if (!UrlIsFileUrlW(uri_w.get())) { - return Utils::CreateCStringUniquePtr(Utils::StrDup(uri_decoder.decoded())); + return CStringUniquePtr(Utils::StrDup(uri_decoder.decoded())); } wchar_t filename_w[MAX_PATH]; DWORD filename_len = MAX_PATH; HRESULT result = PathCreateFromUrlW(uri_w.get(), filename_w, &filename_len, /* dwFlags= */ 0); if (result != S_OK) { - return Utils::CreateCStringUniquePtr(nullptr); + return CStringUniquePtr(nullptr); } WideToUtf8Scope utf8_path(filename_w); diff --git a/runtime/bin/snapshot_utils.cc b/runtime/bin/snapshot_utils.cc index 335a8ef38ab..7e09af07163 100644 --- a/runtime/bin/snapshot_utils.cc +++ b/runtime/bin/snapshot_utils.cc @@ -588,7 +588,7 @@ bool Snapshot::IsPEFormattedBinary(const char* filename) { AppSnapshot* Snapshot::TryReadAppSnapshot(const char* script_uri, bool force_load_elf_from_memory, bool decode_uri) { - Utils::CStringUniquePtr decoded_path(nullptr, std::free); + CStringUniquePtr decoded_path(nullptr); const char* script_name = nullptr; if (decode_uri) { decoded_path = File::UriToPath(script_uri); @@ -636,8 +636,7 @@ AppSnapshot* Snapshot::TryReadAppSnapshot(const char* script_uri, #if defined(DART_TARGET_OS_LINUX) || defined(DART_TARGET_OS_MACOS) // On Linux and OSX, resolve the script path before passing into dlopen() // since dlopen will not search the filesystem for paths like 'libtest.so'. - std::unique_ptr absolute_path{ - realpath(script_name, nullptr), std::free}; + CStringUniquePtr absolute_path(realpath(script_name, nullptr)); script_name = absolute_path.get(); #endif diff --git a/runtime/bin/utils_win.h b/runtime/bin/utils_win.h index 21fc212b353..4f131cdc29c 100644 --- a/runtime/bin/utils_win.h +++ b/runtime/bin/utils_win.h @@ -53,24 +53,24 @@ class StringUtilsWin { class WideToUtf8Scope { public: explicit WideToUtf8Scope(const wchar_t* wide) - : utf8_(Utils::CreateCStringUniquePtr(nullptr)) { + : utf8_(CStringUniquePtr(nullptr)) { intptr_t utf8_len = WideCharToMultiByte(CP_UTF8, 0, wide, -1, nullptr, 0, nullptr, nullptr); char* utf8 = reinterpret_cast(malloc(utf8_len)); WideCharToMultiByte(CP_UTF8, 0, wide, -1, utf8, utf8_len, nullptr, nullptr); length_ = utf8_len; - utf8_ = Utils::CreateCStringUniquePtr(utf8); + utf8_.reset(utf8); } char* utf8() const { return utf8_.get(); } intptr_t length() const { return length_; } // Release the ownership of the converted string and return it. - Utils::CStringUniquePtr release() { return std::move(utf8_); } + CStringUniquePtr release() { return std::move(utf8_); } private: intptr_t length_; - Utils::CStringUniquePtr utf8_; + CStringUniquePtr utf8_; DISALLOW_ALLOCATION(); DISALLOW_IMPLICIT_CONSTRUCTORS(WideToUtf8Scope); diff --git a/runtime/platform/utils.cc b/runtime/platform/utils.cc index e7179ed8040..9eff9923233 100644 --- a/runtime/platform/utils.cc +++ b/runtime/platform/utils.cc @@ -254,10 +254,6 @@ char* Utils::VSCreate(const char* format, va_list args) { return buffer; } -Utils::CStringUniquePtr Utils::CreateCStringUniquePtr(char* str) { - return std::unique_ptr{str, std::free}; -} - static void GetLastErrorAsString(char** error) { if (error == nullptr) return; // Nothing to do. diff --git a/runtime/platform/utils.h b/runtime/platform/utils.h index 18e83926d7c..d9e6950c330 100644 --- a/runtime/platform/utils.h +++ b/runtime/platform/utils.h @@ -15,6 +15,17 @@ namespace dart { +template +class CAllocUniquePtr : public std::unique_ptr { + public: + CAllocUniquePtr() + : std::unique_ptr(nullptr, std::free) {} + explicit CAllocUniquePtr(T* value) + : std::unique_ptr(value, std::free) {} +}; + +using CStringUniquePtr = CAllocUniquePtr; + class Utils { public: template @@ -641,11 +652,6 @@ class Utils { static char* SCreate(const char* format, ...) PRINTF_ATTRIBUTE(1, 2); static char* VSCreate(const char* format, va_list args); - typedef std::unique_ptr CStringUniquePtr; - - // Returns str in a unique_ptr with free used as its deleter. - static CStringUniquePtr CreateCStringUniquePtr(char* str); - // Load dynamic library from the given |library_path| and return the // library handle. |library_path| can be |nullptr| in which case // library handle representing the executable is returned. diff --git a/runtime/vm/compiler/backend/il_test.cc b/runtime/vm/compiler/backend/il_test.cc index c6eff831175..c42feef803c 100644 --- a/runtime/vm/compiler/backend/il_test.cc +++ b/runtime/vm/compiler/backend/il_test.cc @@ -764,7 +764,7 @@ ISOLATE_UNIT_TEST_CASE(IRTest_LoadThread) { #if !defined(TARGET_ARCH_IA32) ISOLATE_UNIT_TEST_CASE(IRTest_CachableIdempotentCall) { // clang-format off - auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, R"( + CStringUniquePtr kScript(OS::SCreate(nullptr, R"( int globalCounter = 0; int increment() => ++globalCounter; @@ -785,7 +785,7 @@ ISOLATE_UNIT_TEST_CASE(IRTest_CachableIdempotentCall) { } return returnValue; } - )"), std::free); + )")); // clang-format on const auto& root_library = Library::Handle(LoadTestScript(kScript.get())); diff --git a/runtime/vm/compiler/backend/memory_copy_test.cc b/runtime/vm/compiler/backend/memory_copy_test.cc index 13f2ab788e6..bb8c974e490 100644 --- a/runtime/vm/compiler/backend/memory_copy_test.cc +++ b/runtime/vm/compiler/backend/memory_copy_test.cc @@ -154,7 +154,7 @@ static void RunMemoryCopyInstrTest(intptr_t src_start, OS::Print("&ptr %p &ptr2 %p\n", ptr, ptr2); // clang-format off - auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, R"( + CStringUniquePtr kScript(OS::SCreate(nullptr, R"( import 'dart:ffi'; void copyConst() { @@ -182,7 +182,7 @@ static void RunMemoryCopyInstrTest(intptr_t src_start, int length) {} )", pointer_prefix, ptr, pointer_prefix, ptr2, pointer_prefix, ptr, pointer_prefix, ptr2, - src_start, dest_start, length), std::free); + src_start, dest_start, length)); // clang-format on const auto& root_library = Library::Handle(LoadTestScript(kScript.get())); diff --git a/runtime/vm/compiler/backend/redundancy_elimination_test.cc b/runtime/vm/compiler/backend/redundancy_elimination_test.cc index cb585bae458..461a363bd6b 100644 --- a/runtime/vm/compiler/backend/redundancy_elimination_test.cc +++ b/runtime/vm/compiler/backend/redundancy_elimination_test.cc @@ -1740,8 +1740,7 @@ ISOLATE_UNIT_TEST_CASE(AllocationSinking_NoViewDataMaterialization) { auto* const kFunctionName = "unalignedUint16"; auto* const kInvokeNoDeoptName = "no_deopt"; auto* const kInvokeDeoptName = "deopt"; - auto kScript = Utils::CStringUniquePtr( - OS::SCreate(nullptr, R"( + CStringUniquePtr kScript(OS::SCreate(nullptr, R"( import 'dart:_internal'; import 'dart:typed_data'; @@ -1779,9 +1778,9 @@ ISOLATE_UNIT_TEST_CASE(AllocationSinking_NoViewDataMaterialization) { return %s(1.0); } )", - kFunctionName, kInvokeNoDeoptName, kFunctionName, - kInvokeDeoptName, kFunctionName), - std::free); + kFunctionName, kInvokeNoDeoptName, + kFunctionName, kInvokeDeoptName, + kFunctionName)); const auto& lib = Library::Handle(LoadTestScript(kScript.get(), NoopNativeLookup)); @@ -1962,9 +1961,8 @@ ISOLATE_UNIT_TEST_CASE(AllocationSinking_NoViewDataMaterialization) { // Verifies that deoptimization at the hoisted BinarySmiOp // doesn't result in the infinite re-optimization loop. ISOLATE_UNIT_TEST_CASE(LICM_Deopt_Regress51220) { - auto kScript = - Utils::CStringUniquePtr(OS::SCreate(nullptr, - R"( + CStringUniquePtr kScript(OS::SCreate(nullptr, + R"( int n = int.parse('3'); main() { int x = 0; @@ -1976,8 +1974,7 @@ ISOLATE_UNIT_TEST_CASE(LICM_Deopt_Regress51220) { return x; } )", - static_cast(kSmiBits + 1 - 10)), - std::free); + static_cast(kSmiBits + 1 - 10))); const auto& root_library = Library::Handle(LoadTestScript(kScript.get())); const auto& function = Function::Handle(GetFunction(root_library, "main")); diff --git a/runtime/vm/compiler/write_barrier_elimination_test.cc b/runtime/vm/compiler/write_barrier_elimination_test.cc index 6f62f235df2..a8fd4d6835c 100644 --- a/runtime/vm/compiler/write_barrier_elimination_test.cc +++ b/runtime/vm/compiler/write_barrier_elimination_test.cc @@ -140,8 +140,7 @@ static void TestWBEForArrays(int length) { // may-trigger-GC instruction (in this case CheckStackOverflow) iff they // are small. // clang-format off - auto kScript = - Utils::CStringUniquePtr(OS::SCreate(nullptr, R"( + CStringUniquePtr kScript(OS::SCreate(nullptr, R"( class C { late C next; } @@ -164,7 +163,7 @@ static void TestWBEForArrays(int length) { } main() { foo(10); } - )", length), std::free); + )", length)); // clang-format on // Generate a length dependent test library uri. diff --git a/runtime/vm/dart_api_impl_test.cc b/runtime/vm/dart_api_impl_test.cc index 91d85a60b70..e657724b53f 100644 --- a/runtime/vm/dart_api_impl_test.cc +++ b/runtime/vm/dart_api_impl_test.cc @@ -10248,36 +10248,31 @@ TEST_CASE(DartAPI_UserTags) { Dart_Handle default_tag = Dart_GetDefaultUserTag(); EXPECT_VALID(default_tag); - auto default_label = - Utils::CStringUniquePtr(Dart_GetUserTagLabel(default_tag), std::free); + CStringUniquePtr default_label(Dart_GetUserTagLabel(default_tag)); EXPECT_STREQ(default_label.get(), "Default"); Dart_Handle current_tag = Dart_GetCurrentUserTag(); EXPECT(Dart_IdentityEquals(default_tag, current_tag)); - auto current_label = - Utils::CStringUniquePtr(Dart_GetUserTagLabel(current_tag), std::free); + CStringUniquePtr current_label(Dart_GetUserTagLabel(current_tag)); EXPECT_STREQ(default_label.get(), current_label.get()); Dart_Handle new_tag = Dart_NewUserTag("Foo"); EXPECT_VALID(new_tag); - auto new_tag_label = - Utils::CStringUniquePtr(Dart_GetUserTagLabel(new_tag), std::free); + CStringUniquePtr new_tag_label(Dart_GetUserTagLabel(new_tag)); EXPECT_STREQ(new_tag_label.get(), "Foo"); Dart_Handle old_tag = Dart_SetCurrentUserTag(new_tag); EXPECT_VALID(old_tag); - auto old_label = - Utils::CStringUniquePtr(Dart_GetUserTagLabel(old_tag), std::free); + CStringUniquePtr old_label(Dart_GetUserTagLabel(old_tag)); EXPECT_STREQ(old_label.get(), default_label.get()); current_tag = Dart_GetCurrentUserTag(); EXPECT(Dart_IdentityEquals(new_tag, current_tag)); - current_label = - Utils::CStringUniquePtr(Dart_GetUserTagLabel(current_tag), std::free); + current_label.reset(Dart_GetUserTagLabel(current_tag)); EXPECT_STREQ(current_label.get(), new_tag_label.get()); EXPECT(Dart_GetUserTagLabel(Dart_Null()) == nullptr); diff --git a/runtime/vm/flags.cc b/runtime/vm/flags.cc index 7b125b9f357..ca0b4ae8a87 100644 --- a/runtime/vm/flags.cc +++ b/runtime/vm/flags.cc @@ -172,8 +172,7 @@ class Flag { // For kString, kOptionHandler, kFlagHandler flags this stores the copy // of the original flag value passed to SetFlagFromString - Utils::CStringUniquePtr string_value_ = - Utils::CreateCStringUniquePtr(nullptr); + CStringUniquePtr string_value_; union { void* addr_; bool* bool_ptr_; diff --git a/runtime/vm/heap/heap_test.cc b/runtime/vm/heap/heap_test.cc index d4dacd659b2..1088a264b3a 100644 --- a/runtime/vm/heap/heap_test.cc +++ b/runtime/vm/heap/heap_test.cc @@ -486,7 +486,7 @@ class HeapTestHelper { class SendAndExitMessagesHandler : public MessageHandler { public: explicit SendAndExitMessagesHandler(Isolate* owner) - : msg_(Utils::CreateCStringUniquePtr(nullptr)), owner_(owner) {} + : msg_(CStringUniquePtr(nullptr)), owner_(owner) {} const char* name() const { return "merge-isolates-heaps-handler"; } @@ -530,7 +530,7 @@ class SendAndExitMessagesHandler : public MessageHandler { virtual Isolate* isolate() const { return owner_; } private: - Utils::CStringUniquePtr msg_; + CStringUniquePtr msg_; Isolate* owner_; }; diff --git a/runtime/vm/isolate_reload_test.cc b/runtime/vm/isolate_reload_test.cc index 4a070c1186e..a355ad0e3c9 100644 --- a/runtime/vm/isolate_reload_test.cc +++ b/runtime/vm/isolate_reload_test.cc @@ -5410,7 +5410,7 @@ static void TestReloadWithFieldChange(const char* prefix, const char* to_type, const char* to_init) { // clang-format off - auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, + CStringUniquePtr kScript(OS::SCreate(nullptr, R"( import 'dart:typed_data'; @@ -5438,7 +5438,7 @@ static void TestReloadWithFieldChange(const char* prefix, from_type, from_init, suffix, - verify), std::free); + verify)); // clang-format on Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), nullptr); @@ -5446,7 +5446,7 @@ static void TestReloadWithFieldChange(const char* prefix, EXPECT_STREQ("Okay", SimpleInvokeStr(lib, "main")); // clang-format off - auto kReloadScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, R"( + CStringUniquePtr kReloadScript(OS::SCreate(nullptr, R"( import 'dart:typed_data'; void doubleEq(double got, double expected) { @@ -5472,7 +5472,7 @@ static void TestReloadWithFieldChange(const char* prefix, } } )", prefix, to_type, to_init, suffix, - verify), std::free); + verify)); // clang-format on lib = TestCase::ReloadTestScript(kReloadScript.get()); diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc index f9d2e00a1e9..3b3385e63e9 100644 --- a/runtime/vm/object.cc +++ b/runtime/vm/object.cc @@ -17855,7 +17855,7 @@ class MallocCodeComments final : public CodeComments { for (intptr_t i = 0; i < length_; i++) { comments_[i].pc_offset = comments.PCOffsetAt(i); comments_[i].comment = - Utils::CreateCStringUniquePtr(Utils::StrDup(comments.CommentAt(i))); + CStringUniquePtr(Utils::StrDup(comments.CommentAt(i))); } } @@ -17872,7 +17872,7 @@ class MallocCodeComments final : public CodeComments { private: struct Comment { intptr_t pc_offset; - Utils::CStringUniquePtr comment{nullptr, std::free}; + CStringUniquePtr comment; }; intptr_t length_; diff --git a/runtime/vm/object_test.cc b/runtime/vm/object_test.cc index 41c7f280741..0c0f4f1c4cb 100644 --- a/runtime/vm/object_test.cc +++ b/runtime/vm/object_test.cc @@ -6445,7 +6445,7 @@ static bool HashCodeEqualsCanonicalizeHash( uint32_t hashcode_canonicalize_vm = kCalculateCanonicalizeHash, bool check_identity = true, bool check_hashcode = true) { - auto kScriptChars = Utils::CStringUniquePtr( + CStringUniquePtr kScriptChars( OS::SCreate(nullptr, "%s" "\n" @@ -6456,8 +6456,7 @@ static bool HashCodeEqualsCanonicalizeHash( "valueIdentityHashCode() {\n" " return identityHashCode(value());\n" "}\n", - value_script), - std::free); + value_script)); Dart_Handle lib = TestCase::LoadTestScript(kScriptChars.get(), nullptr); EXPECT_VALID(lib); diff --git a/runtime/vm/timeline.cc b/runtime/vm/timeline.cc index 9bc89fa12ab..3d6d127f9d1 100644 --- a/runtime/vm/timeline.cc +++ b/runtime/vm/timeline.cc @@ -1000,14 +1000,12 @@ std::unique_ptr TimelineEvent::GetFormattedIsolateGroupId() return formatted_isolate_group_id; } -TimelineTrackMetadata::TimelineTrackMetadata( - intptr_t pid, - intptr_t tid, - Utils::CStringUniquePtr&& track_name) +TimelineTrackMetadata::TimelineTrackMetadata(intptr_t pid, + intptr_t tid, + CStringUniquePtr&& track_name) : pid_(pid), tid_(tid), track_name_(std::move(track_name)) {} -void TimelineTrackMetadata::set_track_name( - Utils::CStringUniquePtr&& track_name) { +void TimelineTrackMetadata::set_track_name(CStringUniquePtr&& track_name) { track_name_ = std::move(track_name); } @@ -1540,13 +1538,13 @@ void TimelineEventRecorder::AddTrackMetadataBasedOnThread( if (entry->value == nullptr) { entry->value = new TimelineTrackMetadata( process_id, trace_id, - Utils::CreateCStringUniquePtr( + CStringUniquePtr( Utils::StrDup(thread_name == nullptr ? "" : thread_name))); } else { TimelineTrackMetadata* value = static_cast(entry->value); ASSERT(process_id == value->pid()); - value->set_track_name(Utils::CreateCStringUniquePtr( + value->set_track_name(CStringUniquePtr( Utils::StrDup(thread_name == nullptr ? "" : thread_name))); } } diff --git a/runtime/vm/timeline.h b/runtime/vm/timeline.h index d62c39ebc2f..2e1eacff689 100644 --- a/runtime/vm/timeline.h +++ b/runtime/vm/timeline.h @@ -638,11 +638,11 @@ class TimelineTrackMetadata { public: TimelineTrackMetadata(intptr_t pid, intptr_t tid, - Utils::CStringUniquePtr&& track_name); + CStringUniquePtr&& track_name); intptr_t pid() const { return pid_; } intptr_t tid() const { return tid_; } const char* track_name() const { return track_name_.get(); } - inline void set_track_name(Utils::CStringUniquePtr&& track_name); + inline void set_track_name(CStringUniquePtr&& track_name); #if !defined(PRODUCT) /* * Prints a Chrome-format event representing the metadata stored by this @@ -665,7 +665,7 @@ class TimelineTrackMetadata { // The trace ID of the thread that this track is associated with. intptr_t tid_; // The name of this track. - Utils::CStringUniquePtr track_name_; + CStringUniquePtr track_name_; }; class AsyncTimelineTrackMetadata {