Remove base's arraysize from Crashpad.
BUG=837308
R=mark@chromium.org
Change-Id: Ibecbfc7bc2d61ee54bc1114e4b20978adbc77db2
Reviewed-on: https://chromium-review.googlesource.com/c/1393921
Reviewed-by: Mark Mentovai <mark@chromium.org>
Commit-Queue: Avi Drissman <avi@chromium.org>
diff --git a/client/crash_report_database_mac.mm b/client/crash_report_database_mac.mm
index 3106dc2..0980fe3 100644
--- a/client/crash_report_database_mac.mm
+++ b/client/crash_report_database_mac.mm
@@ -35,6 +35,7 @@
#include "client/settings.h"
#include "util/file/file_io.h"
#include "util/mac/xattr.h"
+#include "util/misc/arraysize.h"
#include "util/misc/initialization_state_dcheck.h"
#include "util/misc/metrics.h"
@@ -279,7 +280,7 @@
}
// Create the three processing directories for the database.
- for (size_t i = 0; i < arraysize(kReportDirectories); ++i) {
+ for (size_t i = 0; i < ArraySize(kReportDirectories); ++i) {
if (!CreateOrEnsureDirectoryExists(base_dir_.Append(kReportDirectories[i])))
return false;
}
diff --git a/client/crashpad_client_win_test.cc b/client/crashpad_client_win_test.cc
index 99778ba..b950699 100644
--- a/client/crashpad_client_win_test.cc
+++ b/client/crashpad_client_win_test.cc
@@ -17,7 +17,6 @@
#include <vector>
#include "base/files/file_path.h"
-#include "base/macros.h"
#include "base/logging.h"
#include "gtest/gtest.h"
#include "test/test_paths.h"
diff --git a/client/simulate_crash_mac.cc b/client/simulate_crash_mac.cc
index 1e2d8e4..1f7eca9 100644
--- a/client/simulate_crash_mac.cc
+++ b/client/simulate_crash_mac.cc
@@ -20,13 +20,13 @@
#include "base/logging.h"
#include "base/mac/mach_logging.h"
#include "base/mac/scoped_mach_port.h"
-#include "base/macros.h"
#include "base/strings/stringprintf.h"
#include "build/build_config.h"
#include "util/mach/exc_client_variants.h"
#include "util/mach/exception_behaviors.h"
#include "util/mach/exception_ports.h"
#include "util/mach/mach_extensions.h"
+#include "util/misc/arraysize.h"
#include "util/misc/implicit_cast.h"
namespace crashpad {
@@ -191,7 +191,7 @@
base::mac::ScopedMachSendRight thread(mach_thread_self());
exception_type_t exception = kMachExceptionSimulated;
mach_exception_data_type_t codes[] = {0, 0};
- mach_msg_type_number_t code_count = arraysize(codes);
+ mach_msg_type_number_t code_count = ArraySize(codes);
// Look up the handler for EXC_CRASH exceptions in the same way that the
// kernel would: try a thread handler, then a task handler, and finally a host
@@ -213,7 +213,7 @@
bool success = false;
for (size_t target_type_index = 0;
- !success && target_type_index < arraysize(kTargetTypes);
+ !success && target_type_index < ArraySize(kTargetTypes);
++target_type_index) {
ExceptionPorts::ExceptionHandlerVector handlers;
ExceptionPorts exception_ports(kTargetTypes[target_type_index],
diff --git a/client/simulate_crash_mac_test.cc b/client/simulate_crash_mac_test.cc
index 1d63ff6..910971a 100644
--- a/client/simulate_crash_mac_test.cc
+++ b/client/simulate_crash_mac_test.cc
@@ -31,6 +31,7 @@
#include "util/mach/mach_message.h"
#include "util/mach/mach_message_server.h"
#include "util/mach/symbolic_constants_mach.h"
+#include "util/misc/arraysize.h"
#include "util/misc/implicit_cast.h"
namespace crashpad {
@@ -342,15 +343,13 @@
#endif
};
- for (size_t target_index = 0;
- target_index < arraysize(kTargets);
+ for (size_t target_index = 0; target_index < ArraySize(kTargets);
++target_index) {
TestSimulateCrashMac::ExceptionPortsTarget target = kTargets[target_index];
SCOPED_TRACE(base::StringPrintf(
"target_index %zu, target %d", target_index, target));
- for (size_t behavior_index = 0;
- behavior_index < arraysize(kBehaviors);
+ for (size_t behavior_index = 0; behavior_index < ArraySize(kBehaviors);
++behavior_index) {
exception_behavior_t behavior = kBehaviors[behavior_index];
SCOPED_TRACE(base::StringPrintf(
@@ -364,8 +363,7 @@
target, behavior, THREAD_STATE_NONE);
test_simulate_crash_mac.Run();
} else {
- for (size_t flavor_index = 0;
- flavor_index < arraysize(kFlavors);
+ for (size_t flavor_index = 0; flavor_index < ArraySize(kFlavors);
++flavor_index) {
thread_state_flavor_t flavor = kFlavors[flavor_index];
SCOPED_TRACE(base::StringPrintf(
diff --git a/handler/mac/file_limit_annotation.cc b/handler/mac/file_limit_annotation.cc
index cf56eb8..5646bde 100644
--- a/handler/mac/file_limit_annotation.cc
+++ b/handler/mac/file_limit_annotation.cc
@@ -24,10 +24,10 @@
#include <string>
#include "base/format_macros.h"
-#include "base/macros.h"
#include "base/strings/stringprintf.h"
#include "client/crashpad_info.h"
#include "client/simple_string_dictionary.h"
+#include "util/misc/arraysize.h"
#include "util/posix/scoped_dir.h"
namespace crashpad {
@@ -108,7 +108,7 @@
int mib[] = {CTL_KERN, KERN_MAXFILES};
size = sizeof(value);
std::string max_files = FormatFromSysctl(
- sysctl(mib, arraysize(mib), &value, &size, nullptr, 0), &value, &size);
+ sysctl(mib, ArraySize(mib), &value, &size, nullptr, 0), &value, &size);
std::string open_files = CountOpenFileDescriptors();
diff --git a/handler/win/crashy_test_program.cc b/handler/win/crashy_test_program.cc
index a4f4797..d6b4dea 100644
--- a/handler/win/crashy_test_program.cc
+++ b/handler/win/crashy_test_program.cc
@@ -26,10 +26,10 @@
#include "base/files/file_path.h"
#include "base/logging.h"
-#include "base/macros.h"
#include "build/build_config.h"
#include "client/crashpad_client.h"
#include "client/crashpad_info.h"
+#include "util/misc/arraysize.h"
#include "util/win/critical_section_with_debug_info.h"
#include "util/win/get_function.h"
@@ -83,11 +83,11 @@
// All of these allocations are leaked, we want to view them in windbg via
// !vprot.
void* reserve = VirtualAlloc(
- nullptr, arraysize(kPageTypes) * kPageSize, MEM_RESERVE, PAGE_READWRITE);
+ nullptr, ArraySize(kPageTypes) * kPageSize, MEM_RESERVE, PAGE_READWRITE);
PCHECK(reserve) << "VirtualAlloc MEM_RESERVE";
uintptr_t reserve_as_int = reinterpret_cast<uintptr_t>(reserve);
- for (size_t i = 0; i < arraysize(kPageTypes); ++i) {
+ for (size_t i = 0; i < ArraySize(kPageTypes); ++i) {
void* result =
VirtualAlloc(reinterpret_cast<void*>(reserve_as_int + (kPageSize * i)),
kPageSize,
diff --git a/handler/win/hanging_program.cc b/handler/win/hanging_program.cc
index 840c512..49d5cea 100644
--- a/handler/win/hanging_program.cc
+++ b/handler/win/hanging_program.cc
@@ -17,11 +17,11 @@
#include "base/debug/alias.h"
#include "base/logging.h"
-#include "base/macros.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "client/crashpad_client.h"
#include "client/crashpad_info.h"
+#include "util/misc/arraysize.h"
namespace {
@@ -123,8 +123,8 @@
fflush(stdout);
// This is not expected to return.
- DWORD count =
- WaitForMultipleObjects(arraysize(threads), threads, true, INFINITE);
+ DWORD count = WaitForMultipleObjects(
+ static_cast<DWORD>(ArraySize(threads)), threads, true, INFINITE);
if (count == WAIT_FAILED) {
PLOG(ERROR) << "WaitForMultipleObjects";
} else {
diff --git a/minidump/minidump_annotation_writer_test.cc b/minidump/minidump_annotation_writer_test.cc
index 1641d1d..f86ff46 100644
--- a/minidump/minidump_annotation_writer_test.cc
+++ b/minidump/minidump_annotation_writer_test.cc
@@ -16,13 +16,13 @@
#include <memory>
-#include "base/macros.h"
#include "gtest/gtest.h"
#include "minidump/minidump_extensions.h"
#include "minidump/test/minidump_byte_array_writer_test_util.h"
#include "minidump/test/minidump_string_writer_test_util.h"
#include "minidump/test/minidump_writable_test_util.h"
#include "util/file/string_file.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -107,7 +107,7 @@
MinidumpAnnotationListWriter list_writer;
- for (size_t i = 0; i < arraysize(kNames); ++i) {
+ for (size_t i = 0; i < ArraySize(kNames); ++i) {
auto annotation = std::make_unique<MinidumpAnnotationWriter>();
annotation->InitializeWithData(kNames[i], kTypes[i], kValues[i]);
list_writer.AddObject(std::move(annotation));
diff --git a/minidump/minidump_byte_array_writer_test.cc b/minidump/minidump_byte_array_writer_test.cc
index f20ad35..94fad5c 100644
--- a/minidump/minidump_byte_array_writer_test.cc
+++ b/minidump/minidump_byte_array_writer_test.cc
@@ -21,6 +21,7 @@
#include "gtest/gtest.h"
#include "minidump/test/minidump_writable_test_util.h"
#include "util/file/string_file.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -34,7 +35,7 @@
{},
};
- for (size_t i = 0; i < arraysize(kTests); ++i) {
+ for (size_t i = 0; i < ArraySize(kTests); ++i) {
SCOPED_TRACE(base::StringPrintf("index %" PRIuS, i));
StringFile string_file;
@@ -66,7 +67,7 @@
{},
};
- for (size_t i = 0; i < arraysize(kTests); ++i) {
+ for (size_t i = 0; i < ArraySize(kTests); ++i) {
SCOPED_TRACE(base::StringPrintf("index %" PRIuS, i));
crashpad::MinidumpByteArrayWriter writer;
diff --git a/minidump/minidump_exception_writer.cc b/minidump/minidump_exception_writer.cc
index d870de3..b0e1e62 100644
--- a/minidump/minidump_exception_writer.cc
+++ b/minidump/minidump_exception_writer.cc
@@ -21,7 +21,7 @@
#include "minidump/minidump_context_writer.h"
#include "snapshot/exception_snapshot.h"
#include "util/file/file_writer.h"
-#include "util/misc/arraysize_unsafe.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
@@ -65,7 +65,7 @@
const size_t parameters = exception_information.size();
constexpr size_t kMaxParameters =
- ARRAYSIZE_UNSAFE(exception_.ExceptionRecord.ExceptionInformation);
+ ArraySize(exception_.ExceptionRecord.ExceptionInformation);
CHECK_LE(parameters, kMaxParameters);
exception_.ExceptionRecord.NumberParameters =
diff --git a/minidump/minidump_exception_writer_test.cc b/minidump/minidump_exception_writer_test.cc
index e4dc5fa..b3a4e80 100644
--- a/minidump/minidump_exception_writer_test.cc
+++ b/minidump/minidump_exception_writer_test.cc
@@ -29,6 +29,7 @@
#include "snapshot/test/test_exception_snapshot.h"
#include "test/gtest_death.h"
#include "util/file/string_file.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -80,7 +81,7 @@
expected->ExceptionRecord.NumberParameters);
EXPECT_EQ(observed->ExceptionRecord.__unusedAlignment, 0u);
for (size_t index = 0;
- index < arraysize(observed->ExceptionRecord.ExceptionInformation);
+ index < ArraySize(observed->ExceptionRecord.ExceptionInformation);
++index) {
EXPECT_EQ(observed->ExceptionRecord.ExceptionInformation[index],
expected->ExceptionRecord.ExceptionInformation[index]);
diff --git a/minidump/minidump_file_writer_test.cc b/minidump/minidump_file_writer_test.cc
index 067ef96..ef4813e 100644
--- a/minidump/minidump_file_writer_test.cc
+++ b/minidump/minidump_file_writer_test.cc
@@ -36,6 +36,7 @@
#include "snapshot/test/test_thread_snapshot.h"
#include "test/gtest_death.h"
#include "util/file/string_file.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -134,7 +135,7 @@
minidump_file.SetTimestamp(kTimestamp);
static constexpr uint8_t kStreamData[] = "Hello World!";
- constexpr size_t kStreamSize = arraysize(kStreamData);
+ constexpr size_t kStreamSize = ArraySize(kStreamData);
constexpr MinidumpStreamType kStreamType =
static_cast<MinidumpStreamType>(0x4d);
diff --git a/minidump/minidump_memory_writer_test.cc b/minidump/minidump_memory_writer_test.cc
index 60b7fa8..fa71caf 100644
--- a/minidump/minidump_memory_writer_test.cc
+++ b/minidump/minidump_memory_writer_test.cc
@@ -26,6 +26,7 @@
#include "minidump/test/minidump_writable_test_util.h"
#include "snapshot/test/test_memory_snapshot.h"
#include "util/file/string_file.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -340,7 +341,7 @@
TEST(MinidumpMemoryWriter, AddFromSnapshot) {
MINIDUMP_MEMORY_DESCRIPTOR expect_memory_descriptors[3] = {};
- uint8_t values[arraysize(expect_memory_descriptors)] = {};
+ uint8_t values[ArraySize(expect_memory_descriptors)] = {};
expect_memory_descriptors[0].StartOfMemoryRange = 0;
expect_memory_descriptors[0].Memory.DataSize = 0x1000;
@@ -356,8 +357,7 @@
std::vector<std::unique_ptr<TestMemorySnapshot>> memory_snapshots_owner;
std::vector<const MemorySnapshot*> memory_snapshots;
- for (size_t index = 0;
- index < arraysize(expect_memory_descriptors);
+ for (size_t index = 0; index < ArraySize(expect_memory_descriptors);
++index) {
memory_snapshots_owner.push_back(std::make_unique<TestMemorySnapshot>());
TestMemorySnapshot* memory_snapshot = memory_snapshots_owner.back().get();
@@ -396,7 +396,7 @@
TEST(MinidumpMemoryWriter, CoalesceExplicitMultiple) {
MINIDUMP_MEMORY_DESCRIPTOR expect_memory_descriptors[4] = {};
- uint8_t values[arraysize(expect_memory_descriptors)] = {};
+ uint8_t values[ArraySize(expect_memory_descriptors)] = {};
expect_memory_descriptors[0].StartOfMemoryRange = 0;
expect_memory_descriptors[0].Memory.DataSize = 1000;
diff --git a/minidump/minidump_misc_info_writer.cc b/minidump/minidump_misc_info_writer.cc
index d83ed23..2d70d00 100644
--- a/minidump/minidump_misc_info_writer.cc
+++ b/minidump/minidump_misc_info_writer.cc
@@ -26,7 +26,7 @@
#include "snapshot/process_snapshot.h"
#include "snapshot/system_snapshot.h"
#include "util/file/file_writer.h"
-#include "util/misc/arraysize_unsafe.h"
+#include "util/misc/arraysize.h"
#include "util/numeric/in_range_cast.h"
#include "util/numeric/safe_assignment.h"
@@ -302,7 +302,7 @@
internal::MinidumpWriterUtil::AssignUTF8ToUTF16(
misc_info_.TimeZone.StandardName,
- ARRAYSIZE_UNSAFE(misc_info_.TimeZone.StandardName),
+ ArraySize(misc_info_.TimeZone.StandardName),
standard_name);
misc_info_.TimeZone.StandardDate = standard_date;
@@ -310,7 +310,7 @@
internal::MinidumpWriterUtil::AssignUTF8ToUTF16(
misc_info_.TimeZone.DaylightName,
- ARRAYSIZE_UNSAFE(misc_info_.TimeZone.DaylightName),
+ ArraySize(misc_info_.TimeZone.DaylightName),
daylight_name);
misc_info_.TimeZone.DaylightDate = daylight_date;
@@ -327,12 +327,10 @@
misc_info_.Flags1 |= MINIDUMP_MISC4_BUILDSTRING;
internal::MinidumpWriterUtil::AssignUTF8ToUTF16(
- misc_info_.BuildString,
- ARRAYSIZE_UNSAFE(misc_info_.BuildString),
- build_string);
+ misc_info_.BuildString, ArraySize(misc_info_.BuildString), build_string);
internal::MinidumpWriterUtil::AssignUTF8ToUTF16(
misc_info_.DbgBldStr,
- ARRAYSIZE_UNSAFE(misc_info_.DbgBldStr),
+ ArraySize(misc_info_.DbgBldStr),
debug_build_string);
}
diff --git a/minidump/minidump_misc_info_writer_test.cc b/minidump/minidump_misc_info_writer_test.cc
index 3c60ebc..e134ccd 100644
--- a/minidump/minidump_misc_info_writer_test.cc
+++ b/minidump/minidump_misc_info_writer_test.cc
@@ -31,7 +31,7 @@
#include "snapshot/test/test_process_snapshot.h"
#include "snapshot/test/test_system_snapshot.h"
#include "util/file/string_file.h"
-#include "util/misc/arraysize_unsafe.h"
+#include "util/misc/arraysize.h"
#include "util/stdlib/strlcpy.h"
namespace crashpad {
@@ -127,7 +127,7 @@
SCOPED_TRACE("Standard");
ExpectNULPaddedString16Equal(expected->TimeZone.StandardName,
observed->TimeZone.StandardName,
- arraysize(expected->TimeZone.StandardName));
+ ArraySize(expected->TimeZone.StandardName));
ExpectSystemTimeEqual(&expected->TimeZone.StandardDate,
&observed->TimeZone.StandardDate);
EXPECT_EQ(observed->TimeZone.StandardBias, expected->TimeZone.StandardBias);
@@ -136,7 +136,7 @@
SCOPED_TRACE("Daylight");
ExpectNULPaddedString16Equal(expected->TimeZone.DaylightName,
observed->TimeZone.DaylightName,
- arraysize(expected->TimeZone.DaylightName));
+ ArraySize(expected->TimeZone.DaylightName));
ExpectSystemTimeEqual(&expected->TimeZone.DaylightDate,
&observed->TimeZone.DaylightDate);
EXPECT_EQ(observed->TimeZone.DaylightBias, expected->TimeZone.DaylightBias);
@@ -154,13 +154,13 @@
SCOPED_TRACE("BuildString");
ExpectNULPaddedString16Equal(expected->BuildString,
observed->BuildString,
- arraysize(expected->BuildString));
+ ArraySize(expected->BuildString));
}
{
SCOPED_TRACE("DbgBldStr");
ExpectNULPaddedString16Equal(expected->DbgBldStr,
observed->DbgBldStr,
- arraysize(expected->DbgBldStr));
+ ArraySize(expected->DbgBldStr));
}
}
@@ -176,7 +176,7 @@
EXPECT_EQ(observed->XStateData.EnabledFeatures,
expected->XStateData.EnabledFeatures);
for (size_t feature_index = 0;
- feature_index < arraysize(observed->XStateData.Features);
+ feature_index < ArraySize(observed->XStateData.Features);
++feature_index) {
SCOPED_TRACE(base::StringPrintf("feature_index %" PRIuS, feature_index));
EXPECT_EQ(observed->XStateData.Features[feature_index].Offset,
@@ -396,7 +396,7 @@
base::string16 standard_name_utf16 = base::UTF8ToUTF16(kStandardName);
c16lcpy(expected.TimeZone.StandardName,
standard_name_utf16.c_str(),
- ARRAYSIZE_UNSAFE(expected.TimeZone.StandardName));
+ ArraySize(expected.TimeZone.StandardName));
memcpy(&expected.TimeZone.StandardDate,
&kStandardDate,
sizeof(expected.TimeZone.StandardDate));
@@ -404,7 +404,7 @@
base::string16 daylight_name_utf16 = base::UTF8ToUTF16(kDaylightName);
c16lcpy(expected.TimeZone.DaylightName,
daylight_name_utf16.c_str(),
- ARRAYSIZE_UNSAFE(expected.TimeZone.DaylightName));
+ ArraySize(expected.TimeZone.DaylightName));
memcpy(&expected.TimeZone.DaylightDate,
&kDaylightDate,
sizeof(expected.TimeZone.DaylightDate));
@@ -424,10 +424,9 @@
constexpr int32_t kBias = 300;
MINIDUMP_MISC_INFO_N tmp;
ALLOW_UNUSED_LOCAL(tmp);
- std::string standard_name(ARRAYSIZE_UNSAFE(tmp.TimeZone.StandardName) + 1,
- 's');
+ std::string standard_name(ArraySize(tmp.TimeZone.StandardName) + 1, 's');
constexpr int32_t kStandardBias = 0;
- std::string daylight_name(ARRAYSIZE_UNSAFE(tmp.TimeZone.DaylightName), 'd');
+ std::string daylight_name(ArraySize(tmp.TimeZone.DaylightName), 'd');
constexpr int32_t kDaylightBias = -60;
// Test using kSystemTimeZero, because not all platforms will be able to
@@ -458,7 +457,7 @@
base::string16 standard_name_utf16 = base::UTF8ToUTF16(standard_name);
c16lcpy(expected.TimeZone.StandardName,
standard_name_utf16.c_str(),
- ARRAYSIZE_UNSAFE(expected.TimeZone.StandardName));
+ ArraySize(expected.TimeZone.StandardName));
memcpy(&expected.TimeZone.StandardDate,
&kSystemTimeZero,
sizeof(expected.TimeZone.StandardDate));
@@ -466,7 +465,7 @@
base::string16 daylight_name_utf16 = base::UTF8ToUTF16(daylight_name);
c16lcpy(expected.TimeZone.DaylightName,
daylight_name_utf16.c_str(),
- ARRAYSIZE_UNSAFE(expected.TimeZone.DaylightName));
+ ArraySize(expected.TimeZone.DaylightName));
memcpy(&expected.TimeZone.DaylightDate,
&kSystemTimeZero,
sizeof(expected.TimeZone.DaylightDate));
@@ -497,12 +496,12 @@
base::string16 build_string_utf16 = base::UTF8ToUTF16(kBuildString);
c16lcpy(expected.BuildString,
build_string_utf16.c_str(),
- ARRAYSIZE_UNSAFE(expected.BuildString));
+ ArraySize(expected.BuildString));
base::string16 debug_build_string_utf16 =
base::UTF8ToUTF16(kDebugBuildString);
c16lcpy(expected.DbgBldStr,
debug_build_string_utf16.c_str(),
- ARRAYSIZE_UNSAFE(expected.DbgBldStr));
+ ArraySize(expected.DbgBldStr));
ExpectMiscInfoEqual(&expected, observed);
}
@@ -516,8 +515,8 @@
MINIDUMP_MISC_INFO_N tmp;
ALLOW_UNUSED_LOCAL(tmp);
- std::string build_string(ARRAYSIZE_UNSAFE(tmp.BuildString) + 1, 'B');
- std::string debug_build_string(ARRAYSIZE_UNSAFE(tmp.DbgBldStr), 'D');
+ std::string build_string(ArraySize(tmp.BuildString) + 1, 'B');
+ std::string debug_build_string(ArraySize(tmp.DbgBldStr), 'D');
misc_info_writer->SetBuildString(build_string, debug_build_string);
@@ -534,12 +533,12 @@
base::string16 build_string_utf16 = base::UTF8ToUTF16(build_string);
c16lcpy(expected.BuildString,
build_string_utf16.c_str(),
- ARRAYSIZE_UNSAFE(expected.BuildString));
+ ArraySize(expected.BuildString));
base::string16 debug_build_string_utf16 =
base::UTF8ToUTF16(debug_build_string);
c16lcpy(expected.DbgBldStr,
debug_build_string_utf16.c_str(),
- ARRAYSIZE_UNSAFE(expected.DbgBldStr));
+ ArraySize(expected.DbgBldStr));
ExpectMiscInfoEqual(&expected, observed);
}
@@ -679,7 +678,7 @@
base::string16 standard_name_utf16 = base::UTF8ToUTF16(kStandardName);
c16lcpy(expected.TimeZone.StandardName,
standard_name_utf16.c_str(),
- ARRAYSIZE_UNSAFE(expected.TimeZone.StandardName));
+ ArraySize(expected.TimeZone.StandardName));
memcpy(&expected.TimeZone.StandardDate,
&kSystemTimeZero,
sizeof(expected.TimeZone.StandardDate));
@@ -687,7 +686,7 @@
base::string16 daylight_name_utf16 = base::UTF8ToUTF16(kDaylightName);
c16lcpy(expected.TimeZone.DaylightName,
daylight_name_utf16.c_str(),
- ARRAYSIZE_UNSAFE(expected.TimeZone.DaylightName));
+ ArraySize(expected.TimeZone.DaylightName));
memcpy(&expected.TimeZone.DaylightDate,
&kSystemTimeZero,
sizeof(expected.TimeZone.DaylightDate));
@@ -695,12 +694,12 @@
base::string16 build_string_utf16 = base::UTF8ToUTF16(kBuildString);
c16lcpy(expected.BuildString,
build_string_utf16.c_str(),
- ARRAYSIZE_UNSAFE(expected.BuildString));
+ ArraySize(expected.BuildString));
base::string16 debug_build_string_utf16 =
base::UTF8ToUTF16(kDebugBuildString);
c16lcpy(expected.DbgBldStr,
debug_build_string_utf16.c_str(),
- ARRAYSIZE_UNSAFE(expected.DbgBldStr));
+ ArraySize(expected.DbgBldStr));
ExpectMiscInfoEqual(&expected, observed);
}
@@ -744,18 +743,18 @@
expect_misc_info.TimeZone.Bias = 300;
c16lcpy(expect_misc_info.TimeZone.StandardName,
standard_time_name_utf16.c_str(),
- ARRAYSIZE_UNSAFE(expect_misc_info.TimeZone.StandardName));
+ ArraySize(expect_misc_info.TimeZone.StandardName));
expect_misc_info.TimeZone.StandardBias = 0;
c16lcpy(expect_misc_info.TimeZone.DaylightName,
daylight_time_name_utf16.c_str(),
- ARRAYSIZE_UNSAFE(expect_misc_info.TimeZone.DaylightName));
+ ArraySize(expect_misc_info.TimeZone.DaylightName));
expect_misc_info.TimeZone.DaylightBias = -60;
c16lcpy(expect_misc_info.BuildString,
build_string_utf16.c_str(),
- ARRAYSIZE_UNSAFE(expect_misc_info.BuildString));
+ ArraySize(expect_misc_info.BuildString));
c16lcpy(expect_misc_info.DbgBldStr,
debug_build_string_utf16.c_str(),
- ARRAYSIZE_UNSAFE(expect_misc_info.DbgBldStr));
+ ArraySize(expect_misc_info.DbgBldStr));
const timeval kStartTime =
{ static_cast<time_t>(expect_misc_info.ProcessCreateTime), 0 };
diff --git a/minidump/minidump_module_crashpad_info_writer_test.cc b/minidump/minidump_module_crashpad_info_writer_test.cc
index 63a9338..83401ec 100644
--- a/minidump/minidump_module_crashpad_info_writer_test.cc
+++ b/minidump/minidump_module_crashpad_info_writer_test.cc
@@ -28,6 +28,7 @@
#include "minidump/test/minidump_writable_test_util.h"
#include "snapshot/test/test_module_snapshot.h"
#include "util/file/string_file.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -154,9 +155,9 @@
sizeof(MinidumpSimpleStringDictionaryEntry) +
sizeof(MinidumpAnnotationList) + 2 + // padding
sizeof(MinidumpAnnotation) + sizeof(MinidumpUTF8String) +
- arraysize(kEntry) + 2 + // padding
- sizeof(MinidumpUTF8String) + arraysize(kKey) +
- sizeof(MinidumpUTF8String) + arraysize(kValue) +
+ ArraySize(kEntry) + 2 + // padding
+ sizeof(MinidumpUTF8String) + ArraySize(kKey) +
+ sizeof(MinidumpUTF8String) + ArraySize(kValue) +
sizeof(MinidumpUTF8String) + annotation.name.size() + 1 +
sizeof(MinidumpByteArray) + annotation.value.size());
diff --git a/minidump/minidump_module_writer_test.cc b/minidump/minidump_module_writer_test.cc
index 0fddfe8..bef6a8c 100644
--- a/minidump/minidump_module_writer_test.cc
+++ b/minidump/minidump_module_writer_test.cc
@@ -30,6 +30,7 @@
#include "snapshot/test/test_module_snapshot.h"
#include "test/gtest_death.h"
#include "util/file/string_file.h"
+#include "util/misc/arraysize.h"
#include "util/misc/implicit_cast.h"
#include "util/misc/uuid.h"
@@ -650,10 +651,10 @@
TEST(MinidumpModuleWriter, InitializeFromSnapshot) {
MINIDUMP_MODULE expect_modules[3] = {};
- const char* module_paths[arraysize(expect_modules)] = {};
- const char* module_pdbs[arraysize(expect_modules)] = {};
- UUID uuids[arraysize(expect_modules)] = {};
- uint32_t ages[arraysize(expect_modules)] = {};
+ const char* module_paths[ArraySize(expect_modules)] = {};
+ const char* module_pdbs[ArraySize(expect_modules)] = {};
+ UUID uuids[ArraySize(expect_modules)] = {};
+ uint32_t ages[ArraySize(expect_modules)] = {};
expect_modules[0].BaseOfImage = 0x100101000;
expect_modules[0].SizeOfImage = 0xf000;
@@ -705,7 +706,7 @@
std::vector<std::unique_ptr<TestModuleSnapshot>> module_snapshots_owner;
std::vector<const ModuleSnapshot*> module_snapshots;
- for (size_t index = 0; index < arraysize(expect_modules); ++index) {
+ for (size_t index = 0; index < ArraySize(expect_modules); ++index) {
module_snapshots_owner.push_back(std::make_unique<TestModuleSnapshot>());
TestModuleSnapshot* module_snapshot = module_snapshots_owner.back().get();
InitializeTestModuleSnapshotFromMinidumpModule(module_snapshot,
diff --git a/minidump/minidump_rva_list_writer_test.cc b/minidump/minidump_rva_list_writer_test.cc
index 3043287..bd376a9 100644
--- a/minidump/minidump_rva_list_writer_test.cc
+++ b/minidump/minidump_rva_list_writer_test.cc
@@ -22,6 +22,7 @@
#include "minidump/test/minidump_rva_list_test_util.h"
#include "minidump/test/minidump_writable_test_util.h"
#include "util/file/string_file.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -86,10 +87,10 @@
ASSERT_TRUE(list_writer.WriteEverything(&string_file));
const MinidumpRVAList* list =
- MinidumpRVAListAtStart(string_file.string(), arraysize(kValues));
+ MinidumpRVAListAtStart(string_file.string(), ArraySize(kValues));
ASSERT_TRUE(list);
- for (size_t index = 0; index < arraysize(kValues); ++index) {
+ for (size_t index = 0; index < ArraySize(kValues); ++index) {
SCOPED_TRACE(base::StringPrintf("index %" PRIuS, index));
const uint32_t* child = MinidumpWritableAtRVA<uint32_t>(
diff --git a/minidump/minidump_string_writer_test.cc b/minidump/minidump_string_writer_test.cc
index 1d65485..aa73503 100644
--- a/minidump/minidump_string_writer_test.cc
+++ b/minidump/minidump_string_writer_test.cc
@@ -25,6 +25,7 @@
#include "minidump/test/minidump_string_writer_test_util.h"
#include "minidump/test/minidump_writable_test_util.h"
#include "util/file/string_file.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -66,14 +67,14 @@
{4, "\360\220\204\202", 2, {0xd800, 0xdd02}}, // 𐄂 (non-BMP)
};
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
SCOPED_TRACE(base::StringPrintf(
"index %" PRIuS ", input %s", index, kTestData[index].input_string));
// Make sure that the expected output string with its NUL terminator fits in
// the space provided.
ASSERT_EQ(kTestData[index]
- .output_string[arraysize(kTestData[index].output_string) - 1],
+ .output_string[ArraySize(kTestData[index].output_string) - 1],
0);
string_file.Reset();
@@ -118,7 +119,7 @@
"\303\0\251", // NUL in middle of valid sequence
};
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
SCOPED_TRACE(base::StringPrintf(
"index %" PRIuS ", input %s", index, kTestData[index]));
string_file.Reset();
@@ -181,7 +182,7 @@
{4, "\360\220\204\202"}, // 𐄂 (non-BMP)
};
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
SCOPED_TRACE(base::StringPrintf(
"index %" PRIuS ", input %s", index, kTestData[index].string));
diff --git a/minidump/minidump_system_info_writer.cc b/minidump/minidump_system_info_writer.cc
index cc87d24..df0e348 100644
--- a/minidump/minidump_system_info_writer.cc
+++ b/minidump/minidump_system_info_writer.cc
@@ -20,7 +20,7 @@
#include "minidump/minidump_string_writer.h"
#include "snapshot/system_snapshot.h"
#include "util/file/file_writer.h"
-#include "util/misc/arraysize_unsafe.h"
+#include "util/misc/arraysize.h"
#include "util/misc/implicit_cast.h"
namespace crashpad {
@@ -212,7 +212,7 @@
system_info_.ProcessorArchitecture ==
kMinidumpCPUArchitectureX86Win64);
- static_assert(ARRAYSIZE_UNSAFE(system_info_.Cpu.X86CpuInfo.VendorId) == 3,
+ static_assert(ArraySize(system_info_.Cpu.X86CpuInfo.VendorId) == 3,
"VendorId must have 3 elements");
system_info_.Cpu.X86CpuInfo.VendorId[0] = ebx;
@@ -230,7 +230,7 @@
sizeof(registers) == sizeof(system_info_.Cpu.X86CpuInfo.VendorId),
"VendorId sizes must be equal");
- for (size_t index = 0; index < arraysize(registers); ++index) {
+ for (size_t index = 0; index < ArraySize(registers); ++index) {
memcpy(®isters[index],
&vendor[index * sizeof(*registers)],
sizeof(*registers));
@@ -270,9 +270,8 @@
system_info_.ProcessorArchitecture !=
kMinidumpCPUArchitectureX86Win64);
- static_assert(
- ARRAYSIZE_UNSAFE(system_info_.Cpu.OtherCpuInfo.ProcessorFeatures) == 2,
- "ProcessorFeatures must have 2 elements");
+ static_assert(ArraySize(system_info_.Cpu.OtherCpuInfo.ProcessorFeatures) == 2,
+ "ProcessorFeatures must have 2 elements");
system_info_.Cpu.OtherCpuInfo.ProcessorFeatures[0] = features_0;
system_info_.Cpu.OtherCpuInfo.ProcessorFeatures[1] = features_1;
diff --git a/minidump/minidump_thread_id_map_test.cc b/minidump/minidump_thread_id_map_test.cc
index 7c6795a..d64d810 100644
--- a/minidump/minidump_thread_id_map_test.cc
+++ b/minidump/minidump_thread_id_map_test.cc
@@ -21,6 +21,7 @@
#include "base/macros.h"
#include "gtest/gtest.h"
#include "snapshot/test/test_thread_snapshot.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -38,7 +39,7 @@
// testing::Test:
void SetUp() override {
- for (size_t index = 0; index < arraysize(test_thread_snapshots_); ++index) {
+ for (size_t index = 0; index < ArraySize(test_thread_snapshots_); ++index) {
thread_snapshots_.push_back(&test_thread_snapshots_[index]);
}
}
@@ -59,7 +60,7 @@
}
void SetThreadID(size_t index, uint64_t thread_id) {
- ASSERT_LT(index, arraysize(test_thread_snapshots_));
+ ASSERT_LT(index, ArraySize(test_thread_snapshots_));
test_thread_snapshots_[index].SetThreadID(thread_id);
}
diff --git a/minidump/minidump_thread_writer_test.cc b/minidump/minidump_thread_writer_test.cc
index e95c904..63269ce 100644
--- a/minidump/minidump_thread_writer_test.cc
+++ b/minidump/minidump_thread_writer_test.cc
@@ -33,6 +33,7 @@
#include "snapshot/test/test_thread_snapshot.h"
#include "test/gtest_death.h"
#include "util/file/string_file.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -522,10 +523,10 @@
void RunInitializeFromSnapshotTest(bool thread_id_collision) {
using MinidumpContextType = typename Traits::MinidumpContextType;
MINIDUMP_THREAD expect_threads[3] = {};
- uint64_t thread_ids[arraysize(expect_threads)] = {};
- uint8_t memory_values[arraysize(expect_threads)] = {};
- uint32_t context_seeds[arraysize(expect_threads)] = {};
- MINIDUMP_MEMORY_DESCRIPTOR tebs[arraysize(expect_threads)] = {};
+ uint64_t thread_ids[ArraySize(expect_threads)] = {};
+ uint8_t memory_values[ArraySize(expect_threads)] = {};
+ uint32_t context_seeds[ArraySize(expect_threads)] = {};
+ MINIDUMP_MEMORY_DESCRIPTOR tebs[ArraySize(expect_threads)] = {};
constexpr size_t kTebSize = 1024;
@@ -581,7 +582,7 @@
std::vector<std::unique_ptr<TestThreadSnapshot>> thread_snapshots_owner;
std::vector<const ThreadSnapshot*> thread_snapshots;
- for (size_t index = 0; index < arraysize(expect_threads); ++index) {
+ for (size_t index = 0; index < ArraySize(expect_threads); ++index) {
thread_snapshots_owner.push_back(std::make_unique<TestThreadSnapshot>());
TestThreadSnapshot* thread_snapshot = thread_snapshots_owner.back().get();
diff --git a/minidump/minidump_writable.cc b/minidump/minidump_writable.cc
index d2b58f5..c8075c6 100644
--- a/minidump/minidump_writable.cc
+++ b/minidump/minidump_writable.cc
@@ -18,6 +18,7 @@
#include "base/logging.h"
#include "util/file/file_writer.h"
+#include "util/misc/arraysize.h"
#include "util/numeric/safe_assignment.h"
namespace {
@@ -244,7 +245,7 @@
// The number of elements in kZeroes must be at least one less than the
// maximum Alignment() ever encountered.
static constexpr uint8_t kZeroes[kMaximumAlignment - 1] = {};
- DCHECK_LE(leading_pad_bytes_, arraysize(kZeroes));
+ DCHECK_LE(leading_pad_bytes_, ArraySize(kZeroes));
if (leading_pad_bytes_) {
if (!file_writer->Write(&kZeroes, leading_pad_bytes_)) {
diff --git a/minidump/test/minidump_context_test_util.cc b/minidump/test/minidump_context_test_util.cc
index 318b3fc..ae80d00 100644
--- a/minidump/test/minidump_context_test_util.cc
+++ b/minidump/test/minidump_context_test_util.cc
@@ -18,12 +18,12 @@
#include <sys/types.h>
#include "base/format_macros.h"
-#include "base/macros.h"
#include "base/strings/stringprintf.h"
#include "gtest/gtest.h"
#include "snapshot/cpu_context.h"
#include "snapshot/test/test_cpu_context.h"
#include "test/hex_string.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -128,7 +128,7 @@
context->ds = static_cast<uint16_t>(value++);
context->es = static_cast<uint16_t>(value++);
context->ss = static_cast<uint16_t>(value++);
- for (size_t index = 0; index < arraysize(context->vector_register); ++index) {
+ for (size_t index = 0; index < ArraySize(context->vector_register); ++index) {
context->vector_register[index].lo = value++;
context->vector_register[index].hi = value++;
}
@@ -151,7 +151,7 @@
uint32_t value = seed;
- for (size_t index = 0; index < arraysize(context->regs); ++index) {
+ for (size_t index = 0; index < ArraySize(context->regs); ++index) {
context->regs[index] = value++;
}
context->fp = value++;
@@ -162,7 +162,7 @@
context->pc = value++;
context->cpsr = value++;
- for (size_t index = 0; index < arraysize(context->vfp); ++index) {
+ for (size_t index = 0; index < ArraySize(context->vfp); ++index) {
context->vfp[index] = value++;
}
context->fpscr = value++;
@@ -180,7 +180,7 @@
uint32_t value = seed;
- for (size_t index = 0; index < arraysize(context->regs); ++index) {
+ for (size_t index = 0; index < ArraySize(context->regs); ++index) {
context->regs[index] = value++;
}
context->fp = value++;
@@ -189,7 +189,7 @@
context->pc = value++;
context->cpsr = value++;
- for (size_t index = 0; index < arraysize(context->fpsimd); ++index) {
+ for (size_t index = 0; index < ArraySize(context->fpsimd); ++index) {
context->fpsimd[index].lo = value++;
context->fpsimd[index].hi = value++;
}
@@ -209,7 +209,7 @@
uint32_t value = seed;
- for (size_t index = 0; index < arraysize(context->regs); ++index) {
+ for (size_t index = 0; index < ArraySize(context->regs); ++index) {
context->regs[index] = value++;
}
@@ -220,7 +220,7 @@
context->status = value++;
context->cause = value++;
- for (size_t index = 0; index < arraysize(context->fpregs.fregs); ++index) {
+ for (size_t index = 0; index < ArraySize(context->fpregs.fregs); ++index) {
context->fpregs.fregs[index]._fp_fregs = static_cast<float>(value++);
}
@@ -247,7 +247,7 @@
uint64_t value = seed;
- for (size_t index = 0; index < arraysize(context->regs); ++index) {
+ for (size_t index = 0; index < ArraySize(context->regs); ++index) {
context->regs[index] = value++;
}
@@ -258,7 +258,7 @@
context->status = value++;
context->cause = value++;
- for (size_t index = 0; index < arraysize(context->fpregs.dregs); ++index) {
+ for (size_t index = 0; index < ArraySize(context->fpregs.dregs); ++index) {
context->fpregs.dregs[index] = static_cast<double>(value++);
}
context->fpcsr = value++;
@@ -293,35 +293,33 @@
EXPECT_EQ(observed->reserved_3, expected->reserved_3);
EXPECT_EQ(observed->mxcsr, expected->mxcsr);
EXPECT_EQ(observed->mxcsr_mask, expected->mxcsr_mask);
- for (size_t st_mm_index = 0;
- st_mm_index < arraysize(expected->st_mm);
+ for (size_t st_mm_index = 0; st_mm_index < ArraySize(expected->st_mm);
++st_mm_index) {
SCOPED_TRACE(base::StringPrintf("st_mm_index %" PRIuS, st_mm_index));
EXPECT_EQ(BytesToHexString(observed->st_mm[st_mm_index].st,
- arraysize(observed->st_mm[st_mm_index].st)),
+ ArraySize(observed->st_mm[st_mm_index].st)),
BytesToHexString(expected->st_mm[st_mm_index].st,
- arraysize(expected->st_mm[st_mm_index].st)));
+ ArraySize(expected->st_mm[st_mm_index].st)));
EXPECT_EQ(
BytesToHexString(observed->st_mm[st_mm_index].st_reserved,
- arraysize(observed->st_mm[st_mm_index].st_reserved)),
+ ArraySize(observed->st_mm[st_mm_index].st_reserved)),
BytesToHexString(expected->st_mm[st_mm_index].st_reserved,
- arraysize(expected->st_mm[st_mm_index].st_reserved)));
+ ArraySize(expected->st_mm[st_mm_index].st_reserved)));
}
- for (size_t xmm_index = 0;
- xmm_index < arraysize(expected->xmm);
+ for (size_t xmm_index = 0; xmm_index < ArraySize(expected->xmm);
++xmm_index) {
EXPECT_EQ(BytesToHexString(observed->xmm[xmm_index],
- arraysize(observed->xmm[xmm_index])),
+ ArraySize(observed->xmm[xmm_index])),
BytesToHexString(expected->xmm[xmm_index],
- arraysize(expected->xmm[xmm_index])))
+ ArraySize(expected->xmm[xmm_index])))
<< "xmm_index " << xmm_index;
}
EXPECT_EQ(
- BytesToHexString(observed->reserved_4, arraysize(observed->reserved_4)),
- BytesToHexString(expected->reserved_4, arraysize(expected->reserved_4)));
+ BytesToHexString(observed->reserved_4, ArraySize(observed->reserved_4)),
+ BytesToHexString(expected->reserved_4, ArraySize(expected->reserved_4)));
EXPECT_EQ(
- BytesToHexString(observed->available, arraysize(observed->available)),
- BytesToHexString(expected->available, arraysize(expected->available)));
+ BytesToHexString(observed->available, ArraySize(observed->available)),
+ BytesToHexString(expected->available, ArraySize(expected->available)));
}
} // namespace
@@ -346,11 +344,11 @@
EXPECT_EQ(observed->fsave.fpu_cs, expected.fsave.fpu_cs);
EXPECT_EQ(observed->fsave.fpu_dp, expected.fsave.fpu_dp);
EXPECT_EQ(observed->fsave.fpu_ds, expected.fsave.fpu_ds);
- for (size_t index = 0; index < arraysize(expected.fsave.st); ++index) {
+ for (size_t index = 0; index < ArraySize(expected.fsave.st); ++index) {
EXPECT_EQ(BytesToHexString(observed->fsave.st[index],
- arraysize(observed->fsave.st[index])),
+ ArraySize(observed->fsave.st[index])),
BytesToHexString(expected.fsave.st[index],
- arraysize(expected.fsave.st[index])))
+ ArraySize(expected.fsave.st[index])))
<< "index " << index;
}
if (snapshot) {
@@ -449,7 +447,7 @@
ExpectMinidumpContextFxsave(&expected.fxsave, &observed->fxsave);
- for (size_t index = 0; index < arraysize(expected.vector_register); ++index) {
+ for (size_t index = 0; index < ArraySize(expected.vector_register); ++index) {
if (snapshot) {
EXPECT_EQ(observed->vector_register[index].lo, 0u) << "index " << index;
EXPECT_EQ(observed->vector_register[index].hi, 0u) << "index " << index;
@@ -489,7 +487,7 @@
EXPECT_EQ(observed->context_flags, expected.context_flags);
- for (size_t index = 0; index < arraysize(expected.regs); ++index) {
+ for (size_t index = 0; index < ArraySize(expected.regs); ++index) {
EXPECT_EQ(observed->regs[index], expected.regs[index]);
}
EXPECT_EQ(observed->fp, expected.fp);
@@ -500,10 +498,10 @@
EXPECT_EQ(observed->cpsr, expected.cpsr);
EXPECT_EQ(observed->fpscr, expected.fpscr);
- for (size_t index = 0; index < arraysize(expected.vfp); ++index) {
+ for (size_t index = 0; index < ArraySize(expected.vfp); ++index) {
EXPECT_EQ(observed->vfp[index], expected.vfp[index]);
}
- for (size_t index = 0; index < arraysize(expected.extra); ++index) {
+ for (size_t index = 0; index < ArraySize(expected.extra); ++index) {
EXPECT_EQ(observed->extra[index], snapshot ? 0 : expected.extra[index]);
}
}
@@ -516,14 +514,14 @@
EXPECT_EQ(observed->context_flags, expected.context_flags);
- for (size_t index = 0; index < arraysize(expected.regs); ++index) {
+ for (size_t index = 0; index < ArraySize(expected.regs); ++index) {
EXPECT_EQ(observed->regs[index], expected.regs[index]);
}
EXPECT_EQ(observed->cpsr, expected.cpsr);
EXPECT_EQ(observed->fpsr, expected.fpsr);
EXPECT_EQ(observed->fpcr, expected.fpcr);
- for (size_t index = 0; index < arraysize(expected.fpsimd); ++index) {
+ for (size_t index = 0; index < ArraySize(expected.fpsimd); ++index) {
EXPECT_EQ(observed->fpsimd[index].lo, expected.fpsimd[index].lo);
EXPECT_EQ(observed->fpsimd[index].hi, expected.fpsimd[index].hi);
}
@@ -537,7 +535,7 @@
EXPECT_EQ(observed->context_flags, expected.context_flags);
- for (size_t index = 0; index < arraysize(expected.regs); ++index) {
+ for (size_t index = 0; index < ArraySize(expected.regs); ++index) {
EXPECT_EQ(observed->regs[index], expected.regs[index]);
}
@@ -548,7 +546,7 @@
EXPECT_EQ(observed->status, expected.status);
EXPECT_EQ(observed->cause, expected.cause);
- for (size_t index = 0; index < arraysize(expected.fpregs.fregs); ++index) {
+ for (size_t index = 0; index < ArraySize(expected.fpregs.fregs); ++index) {
EXPECT_EQ(observed->fpregs.fregs[index]._fp_fregs,
expected.fpregs.fregs[index]._fp_fregs);
}
@@ -570,7 +568,7 @@
EXPECT_EQ(observed->context_flags, expected.context_flags);
- for (size_t index = 0; index < arraysize(expected.regs); ++index) {
+ for (size_t index = 0; index < ArraySize(expected.regs); ++index) {
EXPECT_EQ(observed->regs[index], expected.regs[index]);
}
@@ -581,7 +579,7 @@
EXPECT_EQ(observed->status, expected.status);
EXPECT_EQ(observed->cause, expected.cause);
- for (size_t index = 0; index < arraysize(expected.fpregs.dregs); ++index) {
+ for (size_t index = 0; index < ArraySize(expected.fpregs.dregs); ++index) {
EXPECT_EQ(observed->fpregs.dregs[index], expected.fpregs.dregs[index]);
}
EXPECT_EQ(observed->fpcsr, expected.fpcsr);
diff --git a/snapshot/capture_memory.cc b/snapshot/capture_memory.cc
index 98f400e..3ffbcd2 100644
--- a/snapshot/capture_memory.cc
+++ b/snapshot/capture_memory.cc
@@ -20,6 +20,7 @@
#include <memory>
#include "snapshot/memory_snapshot.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace internal {
@@ -97,17 +98,17 @@
#elif defined(ARCH_CPU_ARM_FAMILY)
if (context.architecture == kCPUArchitectureARM64) {
MaybeCaptureMemoryAround(delegate, context.arm64->pc);
- for (size_t i = 0; i < arraysize(context.arm64->regs); ++i) {
+ for (size_t i = 0; i < ArraySize(context.arm64->regs); ++i) {
MaybeCaptureMemoryAround(delegate, context.arm64->regs[i]);
}
} else {
MaybeCaptureMemoryAround(delegate, context.arm->pc);
- for (size_t i = 0; i < arraysize(context.arm->regs); ++i) {
+ for (size_t i = 0; i < ArraySize(context.arm->regs); ++i) {
MaybeCaptureMemoryAround(delegate, context.arm->regs[i]);
}
}
#elif defined(ARCH_CPU_MIPS_FAMILY)
- for (size_t i = 0; i < arraysize(context.mipsel->regs); ++i) {
+ for (size_t i = 0; i < ArraySize(context.mipsel->regs); ++i) {
MaybeCaptureMemoryAround(delegate, context.mipsel->regs[i]);
}
#else
diff --git a/snapshot/cpu_context.cc b/snapshot/cpu_context.cc
index 4d7c1e5..0ed1691 100644
--- a/snapshot/cpu_context.cc
+++ b/snapshot/cpu_context.cc
@@ -18,7 +18,7 @@
#include <string.h>
#include "base/logging.h"
-#include "base/macros.h"
+#include "util/misc/arraysize.h"
#include "util/misc/implicit_cast.h"
namespace crashpad {
@@ -55,9 +55,9 @@
fsave->fpu_dp = fxsave.fpu_dp;
fsave->fpu_ds = fxsave.fpu_ds;
fsave->reserved_4 = 0;
- static_assert(arraysize(fsave->st) == arraysize(fxsave.st_mm),
+ static_assert(ArraySize(fsave->st) == ArraySize(fxsave.st_mm),
"FPU stack registers must be equivalent");
- for (size_t index = 0; index < arraysize(fsave->st); ++index) {
+ for (size_t index = 0; index < ArraySize(fsave->st); ++index) {
memcpy(fsave->st[index], fxsave.st_mm[index].st, sizeof(fsave->st[index]));
}
}
@@ -77,9 +77,9 @@
fxsave->reserved_3 = 0;
fxsave->mxcsr = 0;
fxsave->mxcsr_mask = 0;
- static_assert(arraysize(fxsave->st_mm) == arraysize(fsave.st),
+ static_assert(ArraySize(fxsave->st_mm) == ArraySize(fsave.st),
"FPU stack registers must be equivalent");
- for (size_t index = 0; index < arraysize(fsave.st); ++index) {
+ for (size_t index = 0; index < ArraySize(fsave.st); ++index) {
memcpy(fxsave->st_mm[index].st, fsave.st[index], sizeof(fsave.st[index]));
memset(fxsave->st_mm[index].st_reserved,
0,
diff --git a/snapshot/cpu_context_test.cc b/snapshot/cpu_context_test.cc
index 706f2fe..794d9b9 100644
--- a/snapshot/cpu_context_test.cc
+++ b/snapshot/cpu_context_test.cc
@@ -18,9 +18,9 @@
#include <string.h>
#include <sys/types.h>
-#include "base/macros.h"
#include "gtest/gtest.h"
#include "test/hex_string.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -124,7 +124,7 @@
&fxsave.st_mm[6].st, kExponentAllZero, false, kFractionAllZero);
SetX87Register(
&fxsave.st_mm[7].st, kExponentNormal, true, kFractionNormal); // valid
- for (size_t index = 0; index < arraysize(fxsave.st_mm); ++index) {
+ for (size_t index = 0; index < ArraySize(fxsave.st_mm); ++index) {
memset(&fxsave.st_mm[index].st_reserved,
0x5a,
sizeof(fxsave.st_mm[index].st_reserved));
@@ -148,10 +148,10 @@
EXPECT_EQ(fsave.fpu_dp, fxsave.fpu_dp);
EXPECT_EQ(fsave.fpu_ds, fxsave.fpu_ds);
EXPECT_EQ(fsave.reserved_4, 0);
- for (size_t index = 0; index < arraysize(fsave.st); ++index) {
- EXPECT_EQ(BytesToHexString(fsave.st[index], arraysize(fsave.st[index])),
+ for (size_t index = 0; index < ArraySize(fsave.st); ++index) {
+ EXPECT_EQ(BytesToHexString(fsave.st[index], ArraySize(fsave.st[index])),
BytesToHexString(fxsave.st_mm[index].st,
- arraysize(fxsave.st_mm[index].st)))
+ ArraySize(fxsave.st_mm[index].st)))
<< "index " << index;
}
}
@@ -204,14 +204,14 @@
EXPECT_EQ(fxsave.reserved_3, 0);
EXPECT_EQ(fxsave.mxcsr, 0u);
EXPECT_EQ(fxsave.mxcsr_mask, 0u);
- for (size_t index = 0; index < arraysize(fxsave.st_mm); ++index) {
+ for (size_t index = 0; index < ArraySize(fxsave.st_mm); ++index) {
EXPECT_EQ(BytesToHexString(fxsave.st_mm[index].st,
- arraysize(fxsave.st_mm[index].st)),
- BytesToHexString(fsave.st[index], arraysize(fsave.st[index])))
+ ArraySize(fxsave.st_mm[index].st)),
+ BytesToHexString(fsave.st[index], ArraySize(fsave.st[index])))
<< "index " << index;
EXPECT_EQ(BytesToHexString(fxsave.st_mm[index].st_reserved,
- arraysize(fxsave.st_mm[index].st_reserved)),
- std::string(arraysize(fxsave.st_mm[index].st_reserved) * 2, '0'))
+ ArraySize(fxsave.st_mm[index].st_reserved)),
+ std::string(ArraySize(fxsave.st_mm[index].st_reserved) * 2, '0'))
<< "index " << index;
}
size_t unused_len = sizeof(fxsave) - offsetof(decltype(fxsave), xmm);
@@ -318,7 +318,7 @@
// In this set, everything is valid.
fsw = 0 << 11; // top = 0: logical 0-7 maps to physical 0-7
fxsave_tag = 0xff; // nothing empty
- for (size_t index = 0; index < arraysize(st_mm); ++index) {
+ for (size_t index = 0; index < ArraySize(st_mm); ++index) {
SetX87OrMMXRegister(&st_mm[index], kExponentNormal, true, kFractionAllZero);
}
EXPECT_EQ(CPUContextX86::FxsaveToFsaveTagWord(fsw, fxsave_tag, st_mm), 0);
diff --git a/snapshot/fuchsia/memory_map_region_snapshot_fuchsia.cc b/snapshot/fuchsia/memory_map_region_snapshot_fuchsia.cc
index cf2ee61..45d39d2 100644
--- a/snapshot/fuchsia/memory_map_region_snapshot_fuchsia.cc
+++ b/snapshot/fuchsia/memory_map_region_snapshot_fuchsia.cc
@@ -15,6 +15,7 @@
#include "snapshot/fuchsia/memory_map_region_snapshot_fuchsia.h"
#include "base/logging.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace internal {
@@ -49,7 +50,7 @@
const uint32_t index =
flags & (ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_PERM_EXECUTE);
- DCHECK_LT(index, arraysize(mapping));
+ DCHECK_LT(index, ArraySize(mapping));
const uint32_t protect_flags = mapping[index];
DCHECK_NE(protect_flags, 0u);
diff --git a/snapshot/fuchsia/process_reader_fuchsia_test.cc b/snapshot/fuchsia/process_reader_fuchsia_test.cc
index df20bd3..5832a22 100644
--- a/snapshot/fuchsia/process_reader_fuchsia_test.cc
+++ b/snapshot/fuchsia/process_reader_fuchsia_test.cc
@@ -24,6 +24,7 @@
#include "test/multiprocess_exec.h"
#include "test/test_paths.h"
#include "util/fuchsia/scoped_task_suspend.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -34,7 +35,7 @@
ASSERT_TRUE(process_reader.Initialize(*zx::process::self()));
static constexpr char kTestMemory[] = "Some test memory";
- char buffer[arraysize(kTestMemory)];
+ char buffer[ArraySize(kTestMemory)];
ASSERT_TRUE(process_reader.Memory()->Read(
reinterpret_cast<zx_vaddr_t>(kTestMemory), sizeof(kTestMemory), &buffer));
EXPECT_STREQ(kTestMemory, buffer);
diff --git a/snapshot/fuchsia/process_snapshot_fuchsia_test.cc b/snapshot/fuchsia/process_snapshot_fuchsia_test.cc
index 0f3e3bd..ebb612b 100644
--- a/snapshot/fuchsia/process_snapshot_fuchsia_test.cc
+++ b/snapshot/fuchsia/process_snapshot_fuchsia_test.cc
@@ -24,6 +24,7 @@
#include "snapshot/fuchsia/process_snapshot_fuchsia.h"
#include "test/multiprocess_exec.h"
#include "util/fuchsia/scoped_task_suspend.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -103,8 +104,8 @@
private:
void MultiprocessParent() override {
- uintptr_t test_addresses[arraysize(kTestMappingPermAndSizes)];
- for (size_t i = 0; i < arraysize(test_addresses); ++i) {
+ uintptr_t test_addresses[ArraySize(kTestMappingPermAndSizes)];
+ for (size_t i = 0; i < ArraySize(test_addresses); ++i) {
ASSERT_TRUE(ReadFileExactly(
ReadPipeHandle(), &test_addresses[i], sizeof(test_addresses[i])));
}
@@ -114,7 +115,7 @@
ProcessSnapshotFuchsia process_snapshot;
ASSERT_TRUE(process_snapshot.Initialize(*ChildProcess()));
- for (size_t i = 0; i < arraysize(test_addresses); ++i) {
+ for (size_t i = 0; i < ArraySize(test_addresses); ++i) {
const auto& t = kTestMappingPermAndSizes[i];
EXPECT_TRUE(HasSingleMatchingMapping(process_snapshot.MemoryMap(),
test_addresses[i],
diff --git a/snapshot/linux/exception_snapshot_linux_test.cc b/snapshot/linux/exception_snapshot_linux_test.cc
index 72d36d8..e632bc1 100644
--- a/snapshot/linux/exception_snapshot_linux_test.cc
+++ b/snapshot/linux/exception_snapshot_linux_test.cc
@@ -32,6 +32,7 @@
#include "test/errors.h"
#include "test/linux/fake_ptrace_connection.h"
#include "util/linux/address_types.h"
+#include "util/misc/arraysize.h"
#include "util/misc/clock.h"
#include "util/misc/from_pointer_cast.h"
#include "util/posix/signals.h"
@@ -170,7 +171,7 @@
test_context->vfp.head.magic = VFP_MAGIC;
test_context->vfp.head.size = sizeof(test_context->vfp);
memset(&test_context->vfp.context, 'v', sizeof(test_context->vfp.context));
- for (size_t reg = 0; reg < arraysize(test_context->vfp.context.vfp.fpregs);
+ for (size_t reg = 0; reg < ArraySize(test_context->vfp.context.vfp.fpregs);
++reg) {
test_context->vfp.context.vfp.fpregs[reg] = reg;
}
@@ -218,7 +219,7 @@
void InitializeContext(NativeCPUContext* context) {
memset(context, 'x', sizeof(*context));
- for (size_t index = 0; index < arraysize(context->uc_mcontext.regs);
+ for (size_t index = 0; index < ArraySize(context->uc_mcontext.regs);
++index) {
context->uc_mcontext.regs[index] = index;
}
@@ -237,7 +238,7 @@
test_context->fpsimd.head.size = sizeof(test_context->fpsimd);
test_context->fpsimd.fpsr = 1;
test_context->fpsimd.fpcr = 2;
- for (size_t reg = 0; reg < arraysize(test_context->fpsimd.vregs); ++reg) {
+ for (size_t reg = 0; reg < ArraySize(test_context->fpsimd.vregs); ++reg) {
test_context->fpsimd.vregs[reg] = reg;
}
@@ -270,7 +271,7 @@
using NativeCPUContext = ucontext_t;
void InitializeContext(NativeCPUContext* context) {
- for (size_t reg = 0; reg < arraysize(context->uc_mcontext.gregs); ++reg) {
+ for (size_t reg = 0; reg < ArraySize(context->uc_mcontext.gregs); ++reg) {
context->uc_mcontext.gregs[reg] = reg;
}
memset(&context->uc_mcontext.fpregs, 44, sizeof(context->uc_mcontext.fpregs));
@@ -285,7 +286,7 @@
#define CPU_ARCH_NAME mips64
#endif
- for (size_t reg = 0; reg < arraysize(expected.uc_mcontext.gregs); ++reg) {
+ for (size_t reg = 0; reg < ArraySize(expected.uc_mcontext.gregs); ++reg) {
EXPECT_EQ(actual.CPU_ARCH_NAME->regs[reg], expected.uc_mcontext.gregs[reg]);
}
diff --git a/snapshot/linux/process_reader_linux_test.cc b/snapshot/linux/process_reader_linux_test.cc
index 1edc5ab..61b84f3 100644
--- a/snapshot/linux/process_reader_linux_test.cc
+++ b/snapshot/linux/process_reader_linux_test.cc
@@ -47,6 +47,7 @@
#include "util/file/filesystem.h"
#include "util/linux/direct_ptrace_connection.h"
#include "util/misc/address_sanitizer.h"
+#include "util/misc/arraysize.h"
#include "util/misc/from_pointer_cast.h"
#include "util/synchronization/semaphore.h"
@@ -79,7 +80,7 @@
EXPECT_EQ(process_reader.ParentProcessID(), getppid());
static constexpr char kTestMemory[] = "Some test memory";
- char buffer[arraysize(kTestMemory)];
+ char buffer[ArraySize(kTestMemory)];
ASSERT_TRUE(process_reader.Memory()->Read(
reinterpret_cast<LinuxVMAddress>(kTestMemory),
sizeof(kTestMemory),
diff --git a/snapshot/mac/mach_o_image_reader.cc b/snapshot/mac/mach_o_image_reader.cc
index 6baee77..650b0c7 100644
--- a/snapshot/mac/mach_o_image_reader.cc
+++ b/snapshot/mac/mach_o_image_reader.cc
@@ -28,6 +28,7 @@
#include "snapshot/mac/mach_o_image_symbol_table_reader.h"
#include "snapshot/mac/process_reader_mac.h"
#include "util/mac/checked_mach_address_range.h"
+#include "util/misc/arraysize.h"
#include "util/misc/implicit_cast.h"
namespace {
@@ -182,7 +183,7 @@
// This vector is parallel to the kLoadCommandReaders array, and tracks
// whether a singleton load command matching the |command| field has been
// found yet.
- std::vector<uint32_t> singleton_indices(arraysize(kLoadCommandReaders),
+ std::vector<uint32_t> singleton_indices(ArraySize(kLoadCommandReaders),
kInvalidSegmentIndex);
size_t offset = mach_header.Size();
@@ -235,8 +236,7 @@
return false;
}
- for (size_t reader_index = 0;
- reader_index < arraysize(kLoadCommandReaders);
+ for (size_t reader_index = 0; reader_index < ArraySize(kLoadCommandReaders);
++reader_index) {
if (load_command.cmd != kLoadCommandReaders[reader_index].command) {
continue;
diff --git a/snapshot/mac/mach_o_image_segment_reader_test.cc b/snapshot/mac/mach_o_image_segment_reader_test.cc
index 2da97e8..cfbddc1 100644
--- a/snapshot/mac/mach_o_image_segment_reader_test.cc
+++ b/snapshot/mac/mach_o_image_segment_reader_test.cc
@@ -16,9 +16,9 @@
#include <mach-o/loader.h>
-#include "base/macros.h"
#include "base/strings/stringprintf.h"
#include "gtest/gtest.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -63,7 +63,7 @@
SEG_IMPORT,
};
- for (size_t index = 0; index < arraysize(kSegmentTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kSegmentTestData); ++index) {
EXPECT_EQ(
MachOImageSegmentReader::SegmentNameString(kSegmentTestData[index]),
kSegmentTestData[index])
@@ -106,7 +106,7 @@
SECT_ICON_TIFF,
};
- for (size_t index = 0; index < arraysize(kSectionTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kSectionTestData); ++index) {
EXPECT_EQ(
MachOImageSegmentReader::SectionNameString(kSectionTestData[index]),
kSectionTestData[index])
@@ -169,7 +169,7 @@
{SEG_IMPORT, "", "__IMPORT,"},
};
- for (size_t index = 0; index < arraysize(kSegmentAndSectionTestData);
+ for (size_t index = 0; index < ArraySize(kSegmentAndSectionTestData);
++index) {
const auto& test = kSegmentAndSectionTestData[index];
EXPECT_EQ(MachOImageSegmentReader::SegmentAndSectionNameString(
diff --git a/snapshot/mac/process_reader_mac_test.cc b/snapshot/mac/process_reader_mac_test.cc
index cf3604c..e3f4df1 100644
--- a/snapshot/mac/process_reader_mac_test.cc
+++ b/snapshot/mac/process_reader_mac_test.cc
@@ -41,6 +41,7 @@
#include "util/file/file_io.h"
#include "util/mac/mac_util.h"
#include "util/mach/mach_extensions.h"
+#include "util/misc/arraysize.h"
#include "util/misc/from_pointer_cast.h"
#include "util/synchronization/semaphore.h"
@@ -64,7 +65,7 @@
EXPECT_EQ(process_reader.ParentProcessID(), getppid());
static constexpr char kTestMemory[] = "Some test memory";
- char buffer[arraysize(kTestMemory)];
+ char buffer[ArraySize(kTestMemory)];
ASSERT_TRUE(process_reader.Memory()->Read(
FromPointerCast<mach_vm_address_t>(kTestMemory),
sizeof(kTestMemory),
@@ -612,11 +613,11 @@
const size_t source_lengths[] = {
strlen(sources[0]),
};
- static_assert(arraysize(sources) == arraysize(source_lengths),
+ static_assert(ArraySize(sources) == ArraySize(source_lengths),
"arrays must be parallel");
program_ = clCreateProgramWithSource(
- context_, arraysize(sources), sources, source_lengths, &rv);
+ context_, ArraySize(sources), sources, source_lengths, &rv);
ASSERT_EQ(rv, CL_SUCCESS) << "clCreateProgramWithSource";
rv = clBuildProgram(
diff --git a/snapshot/mac/process_types.cc b/snapshot/mac/process_types.cc
index cbb114d..9ae8f7c 100644
--- a/snapshot/mac/process_types.cc
+++ b/snapshot/mac/process_types.cc
@@ -20,8 +20,8 @@
#include <memory>
-#include "base/macros.h"
#include "snapshot/mac/process_types/internal.h"
+#include "util/misc/arraysize.h"
#include "util/process/process_memory_mac.h"
namespace crashpad {
@@ -74,7 +74,7 @@
template <>
inline void Assign<UInt64Array4, UInt32Array4>(UInt64Array4* destination,
const UInt32Array4& source) {
- for (size_t index = 0; index < arraysize(source); ++index) {
+ for (size_t index = 0; index < ArraySize(source); ++index) {
(*destination)[index] = source[index];
}
}
diff --git a/snapshot/mac/process_types/custom.cc b/snapshot/mac/process_types/custom.cc
index 9020965..3d5976c 100644
--- a/snapshot/mac/process_types/custom.cc
+++ b/snapshot/mac/process_types/custom.cc
@@ -25,6 +25,7 @@
#include "base/numerics/safe_math.h"
#include "base/strings/stringprintf.h"
#include "snapshot/mac/process_types/internal.h"
+#include "util/misc/arraysize.h"
#include "util/process/process_memory_mac.h"
#if !DOXYGEN
@@ -144,8 +145,8 @@
sizeof(dyld_all_image_infos<Traits>), // 16
};
- if (version >= arraysize(kSizeForVersion)) {
- return kSizeForVersion[arraysize(kSizeForVersion) - 1];
+ if (version >= ArraySize(kSizeForVersion)) {
+ return kSizeForVersion[ArraySize(kSizeForVersion) - 1];
}
static_assert(std::is_unsigned<decltype(version)>::value,
diff --git a/snapshot/mac/process_types_test.cc b/snapshot/mac/process_types_test.cc
index f116c4d..9a9dc9d 100644
--- a/snapshot/mac/process_types_test.cc
+++ b/snapshot/mac/process_types_test.cc
@@ -20,13 +20,13 @@
#include <vector>
-#include "base/macros.h"
#include "base/strings/stringprintf.h"
#include "build/build_config.h"
#include "gtest/gtest.h"
#include "snapshot/mac/process_types/internal.h"
#include "test/mac/dyld.h"
#include "util/mac/mac_util.h"
+#include "util/misc/arraysize.h"
#include "util/misc/from_pointer_cast.h"
#include "util/misc/implicit_cast.h"
@@ -147,7 +147,7 @@
{15, 164, 304},
{16, 176, 320},
};
- for (size_t index = 0; index < arraysize(kVersionsAndSizes); ++index) {
+ for (size_t index = 0; index < ArraySize(kVersionsAndSizes); ++index) {
uint32_t version = kVersionsAndSizes[index].version;
SCOPED_TRACE(base::StringPrintf("index %zu, version %u", index, version));
@@ -268,8 +268,7 @@
self_image_infos->sharedCacheBaseAddress);
EXPECT_EQ(proctype_image_infos.dyldPath,
reinterpret_cast<uint64_t>(self_image_infos->dyldPath));
- for (size_t index = 0;
- index < arraysize(self_image_infos->notifyPorts);
+ for (size_t index = 0; index < ArraySize(self_image_infos->notifyPorts);
++index) {
EXPECT_EQ(proctype_image_infos.notifyPorts[index],
self_image_infos->notifyPorts[index])
@@ -289,8 +288,7 @@
// process_types version. It’s difficult to compare the reserved fields in
// these older SDKs, so only do it where the declarations match.
if (proctype_image_infos.version >= 14) {
- for (size_t index = 0;
- index < arraysize(proctype_image_infos.reserved);
+ for (size_t index = 0; index < ArraySize(proctype_image_infos.reserved);
++index) {
EXPECT_EQ(proctype_image_infos.reserved[index],
implicit_cast<uint64_t>(self_image_infos->reserved[index]))
diff --git a/snapshot/minidump/process_snapshot_minidump_test.cc b/snapshot/minidump/process_snapshot_minidump_test.cc
index 52b0992..4787603 100644
--- a/snapshot/minidump/process_snapshot_minidump_test.cc
+++ b/snapshot/minidump/process_snapshot_minidump_test.cc
@@ -28,6 +28,7 @@
#include "snapshot/minidump/minidump_annotation_reader.h"
#include "snapshot/module_snapshot.h"
#include "util/file/string_file.h"
+#include "util/misc/arraysize.h"
#include "util/misc/pdb_structures.h"
namespace crashpad {
@@ -858,27 +859,27 @@
minidump_context.fxsave.fpu_ip_64 = 42;
minidump_context.fxsave.fpu_dp_64 = 43;
- for (size_t i = 0; i < arraysize(minidump_context.vector_register); i++) {
+ for (size_t i = 0; i < ArraySize(minidump_context.vector_register); i++) {
minidump_context.vector_register[i].lo = i * 2 + 44;
minidump_context.vector_register[i].hi = i * 2 + 45;
}
- for (uint8_t i = 0; i < arraysize(minidump_context.fxsave.reserved_4); i++) {
+ for (uint8_t i = 0; i < ArraySize(minidump_context.fxsave.reserved_4); i++) {
minidump_context.fxsave.reserved_4[i] = i * 2 + 115;
minidump_context.fxsave.available[i] = i * 2 + 116;
}
- for (size_t i = 0; i < arraysize(minidump_context.fxsave.st_mm); i++) {
+ for (size_t i = 0; i < ArraySize(minidump_context.fxsave.st_mm); i++) {
for (uint8_t j = 0;
- j < arraysize(minidump_context.fxsave.st_mm[0].mm_value);
+ j < ArraySize(minidump_context.fxsave.st_mm[0].mm_value);
j++) {
minidump_context.fxsave.st_mm[i].mm_value[j] = j + 1;
minidump_context.fxsave.st_mm[i].mm_reserved[j] = j + 1;
}
}
- for (size_t i = 0; i < arraysize(minidump_context.fxsave.xmm); i++) {
- for (uint8_t j = 0; j < arraysize(minidump_context.fxsave.xmm[0]); j++) {
+ for (size_t i = 0; i < ArraySize(minidump_context.fxsave.xmm); i++) {
+ for (uint8_t j = 0; j < ArraySize(minidump_context.fxsave.xmm[0]); j++) {
minidump_context.fxsave.xmm[i][j] = j + 1;
}
}
@@ -961,22 +962,20 @@
EXPECT_EQ(ctx->fxsave.fpu_ip_64, 42U);
EXPECT_EQ(ctx->fxsave.fpu_dp_64, 43U);
- for (uint8_t i = 0; i < arraysize(ctx->fxsave.reserved_4); i++) {
+ for (uint8_t i = 0; i < ArraySize(ctx->fxsave.reserved_4); i++) {
EXPECT_EQ(ctx->fxsave.reserved_4[i], i * 2 + 115);
EXPECT_EQ(ctx->fxsave.available[i], i * 2 + 116);
}
- for (size_t i = 0; i < arraysize(ctx->fxsave.st_mm); i++) {
- for (uint8_t j = 0;
- j < arraysize(ctx->fxsave.st_mm[0].mm_value);
- j++) {
+ for (size_t i = 0; i < ArraySize(ctx->fxsave.st_mm); i++) {
+ for (uint8_t j = 0; j < ArraySize(ctx->fxsave.st_mm[0].mm_value); j++) {
EXPECT_EQ(ctx->fxsave.st_mm[i].mm_value[j], j + 1);
EXPECT_EQ(ctx->fxsave.st_mm[i].mm_reserved[j], j + 1);
}
}
- for (size_t i = 0; i < arraysize(ctx->fxsave.xmm); i++) {
- for (uint8_t j = 0; j < arraysize(ctx->fxsave.xmm[0]); j++) {
+ for (size_t i = 0; i < ArraySize(ctx->fxsave.xmm); i++) {
+ for (uint8_t j = 0; j < ArraySize(ctx->fxsave.xmm[0]); j++) {
EXPECT_EQ(ctx->fxsave.xmm[i][j], j + 1);
}
}
diff --git a/snapshot/minidump/thread_snapshot_minidump.cc b/snapshot/minidump/thread_snapshot_minidump.cc
index 00e0e9b..46ae97a 100644
--- a/snapshot/minidump/thread_snapshot_minidump.cc
+++ b/snapshot/minidump/thread_snapshot_minidump.cc
@@ -18,6 +18,7 @@
#include <string.h>
#include "minidump/minidump_context.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace internal {
@@ -192,7 +193,7 @@
return false;
}
- for (size_t i = 0; i < arraysize(src->regs); i++) {
+ for (size_t i = 0; i < ArraySize(src->regs); i++) {
context_.arm->regs[i] = src->regs[i];
}
@@ -204,7 +205,7 @@
context_.arm->cpsr = src->cpsr;
context_.arm->vfp_regs.fpscr = src->fpscr;
- for (size_t i = 0; i < arraysize(src->vfp); i++) {
+ for (size_t i = 0; i < ArraySize(src->vfp); i++) {
context_.arm->vfp_regs.vfp[i] = src->vfp[i];
}
@@ -224,14 +225,14 @@
return false;
}
- for (size_t i = 0; i < arraysize(src->regs); i++) {
+ for (size_t i = 0; i < ArraySize(src->regs); i++) {
context_.arm64->regs[i] = src->regs[i];
}
context_.arm64->regs[29] = src->fp;
context_.arm64->regs[30] = src->lr;
- for (size_t i = 0; i < arraysize(src->fpsimd); i++) {
+ for (size_t i = 0; i < ArraySize(src->fpsimd); i++) {
context_.arm64->fpsimd[i] = src->fpsimd[i];
}
@@ -254,7 +255,7 @@
return false;
}
- for (size_t i = 0; i < arraysize(src->regs); i++) {
+ for (size_t i = 0; i < ArraySize(src->regs); i++) {
context_.mipsel->regs[i] = src->regs[i];
}
@@ -262,7 +263,7 @@
context_.mipsel->mdlo = static_cast<uint32_t>(src->mdlo);
context_.mipsel->dsp_control = src->dsp_control;
- for (size_t i = 0; i < arraysize(src->hi); i++) {
+ for (size_t i = 0; i < ArraySize(src->hi); i++) {
context_.mipsel->hi[i] = src->hi[i];
context_.mipsel->lo[i] = src->lo[i];
}
@@ -291,7 +292,7 @@
return false;
}
- for (size_t i = 0; i < arraysize(src->regs); i++) {
+ for (size_t i = 0; i < ArraySize(src->regs); i++) {
context_.mips64->regs[i] = src->regs[i];
}
@@ -299,7 +300,7 @@
context_.mips64->mdlo = src->mdlo;
context_.mips64->dsp_control = src->dsp_control;
- for (size_t i = 0; i < arraysize(src->hi); i++) {
+ for (size_t i = 0; i < ArraySize(src->hi); i++) {
context_.mips64->hi[i] = src->hi[i];
context_.mips64->lo[i] = src->lo[i];
}
diff --git a/snapshot/posix/timezone.cc b/snapshot/posix/timezone.cc
index 47c6ecf..8b2b822 100644
--- a/snapshot/posix/timezone.cc
+++ b/snapshot/posix/timezone.cc
@@ -19,6 +19,7 @@
#include "base/logging.h"
#include "build/build_config.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace internal {
@@ -59,8 +60,7 @@
static constexpr int kMonthDeltas[] =
{0, 1, -1, 2, -2, 3, -3, 4, -4, 5, -5, 6, -6,
7, -7, 8, -8, 9, -9, 10, -10, 11, -11, 12, -12};
- for (size_t index = 0;
- index < arraysize(kMonthDeltas) && !found_transition;
+ for (size_t index = 0; index < ArraySize(kMonthDeltas) && !found_transition;
++index) {
// Look at a day of each month at local noon. Set tm_isdst to -1 to avoid
// giving mktime() any hints about whether to consider daylight saving
diff --git a/snapshot/posix/timezone_test.cc b/snapshot/posix/timezone_test.cc
index 814506f..1bb19c4 100644
--- a/snapshot/posix/timezone_test.cc
+++ b/snapshot/posix/timezone_test.cc
@@ -25,6 +25,7 @@
#include "base/strings/stringprintf.h"
#include "gtest/gtest.h"
#include "test/errors.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -154,7 +155,7 @@
{"UTC", false, 0, 0, "UTC", "UTC"},
};
- for (size_t index = 0; index < arraysize(kTestTimeZones); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestTimeZones); ++index) {
const auto& test_time_zone = kTestTimeZones[index];
const char* tz = test_time_zone.tz;
SCOPED_TRACE(base::StringPrintf("index %zu, tz %s", index, tz));
diff --git a/snapshot/sanitized/sanitization_information_test.cc b/snapshot/sanitized/sanitization_information_test.cc
index a7bf826..c7d836a 100644
--- a/snapshot/sanitized/sanitization_information_test.cc
+++ b/snapshot/sanitized/sanitization_information_test.cc
@@ -16,6 +16,7 @@
#include "build/build_config.h"
#include "gtest/gtest.h"
+#include "util/misc/arraysize.h"
#include "util/misc/from_pointer_cast.h"
#include "util/process/process_memory_linux.h"
@@ -59,8 +60,8 @@
TEST_F(WhitelistTest, NonEmptyWhitelist) {
ASSERT_TRUE(ReadWhitelist(kNonEmptyWhitelist));
- ASSERT_EQ(whitelist_.size(), arraysize(kNonEmptyWhitelist) - 1);
- for (size_t index = 0; index < arraysize(kNonEmptyWhitelist) - 1; ++index) {
+ ASSERT_EQ(whitelist_.size(), ArraySize(kNonEmptyWhitelist) - 1);
+ for (size_t index = 0; index < ArraySize(kNonEmptyWhitelist) - 1; ++index) {
EXPECT_EQ(whitelist_[index], kNonEmptyWhitelist[index]);
}
}
diff --git a/snapshot/test/test_cpu_context.cc b/snapshot/test/test_cpu_context.cc
index 8e712b7..7694d7e 100644
--- a/snapshot/test/test_cpu_context.cc
+++ b/snapshot/test/test_cpu_context.cc
@@ -17,7 +17,7 @@
#include <string.h>
#include <sys/types.h>
-#include "base/macros.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -44,28 +44,28 @@
fxsave->reserved_3 = static_cast<uint16_t>(value++);
fxsave->mxcsr = value++;
fxsave->mxcsr_mask = value++;
- for (size_t st_mm_index = 0; st_mm_index < arraysize(fxsave->st_mm);
+ for (size_t st_mm_index = 0; st_mm_index < ArraySize(fxsave->st_mm);
++st_mm_index) {
- for (size_t byte = 0; byte < arraysize(fxsave->st_mm[st_mm_index].st);
+ for (size_t byte = 0; byte < ArraySize(fxsave->st_mm[st_mm_index].st);
++byte) {
fxsave->st_mm[st_mm_index].st[byte] = static_cast<uint8_t>(value++);
}
for (size_t byte = 0;
- byte < arraysize(fxsave->st_mm[st_mm_index].st_reserved);
+ byte < ArraySize(fxsave->st_mm[st_mm_index].st_reserved);
++byte) {
fxsave->st_mm[st_mm_index].st_reserved[byte] =
static_cast<uint8_t>(value);
}
}
- for (size_t xmm_index = 0; xmm_index < arraysize(fxsave->xmm); ++xmm_index) {
- for (size_t byte = 0; byte < arraysize(fxsave->xmm[xmm_index]); ++byte) {
+ for (size_t xmm_index = 0; xmm_index < ArraySize(fxsave->xmm); ++xmm_index) {
+ for (size_t byte = 0; byte < ArraySize(fxsave->xmm[xmm_index]); ++byte) {
fxsave->xmm[xmm_index][byte] = static_cast<uint8_t>(value++);
}
}
- for (size_t byte = 0; byte < arraysize(fxsave->reserved_4); ++byte) {
+ for (size_t byte = 0; byte < ArraySize(fxsave->reserved_4); ++byte) {
fxsave->reserved_4[byte] = static_cast<uint8_t>(value++);
}
- for (size_t byte = 0; byte < arraysize(fxsave->available); ++byte) {
+ for (size_t byte = 0; byte < ArraySize(fxsave->available); ++byte) {
fxsave->available[byte] = static_cast<uint8_t>(value++);
}
@@ -174,7 +174,7 @@
uint32_t value = seed;
- for (size_t index = 0; index < arraysize(arm->regs); ++index) {
+ for (size_t index = 0; index < ArraySize(arm->regs); ++index) {
arm->regs[index] = value++;
}
arm->fp = value++;
@@ -185,7 +185,7 @@
arm->pc = value++;
arm->cpsr = value++;
- for (size_t index = 0; index < arraysize(arm->vfp_regs.vfp); ++index) {
+ for (size_t index = 0; index < ArraySize(arm->vfp_regs.vfp); ++index) {
arm->vfp_regs.vfp[index] = value++;
}
arm->vfp_regs.fpscr = value++;
@@ -205,14 +205,14 @@
uint32_t value = seed;
- for (size_t index = 0; index < arraysize(arm64->regs); ++index) {
+ for (size_t index = 0; index < ArraySize(arm64->regs); ++index) {
arm64->regs[index] = value++;
}
arm64->sp = value++;
arm64->pc = value++;
arm64->spsr = value++;
- for (size_t index = 0; index < arraysize(arm64->fpsimd); ++index) {
+ for (size_t index = 0; index < ArraySize(arm64->fpsimd); ++index) {
arm64->fpsimd[index].lo = value++;
arm64->fpsimd[index].hi = value++;
}
@@ -231,7 +231,7 @@
uint32_t value = seed;
- for (size_t index = 0; index < arraysize(mipsel->regs); ++index) {
+ for (size_t index = 0; index < ArraySize(mipsel->regs); ++index) {
mipsel->regs[index] = value++;
}
@@ -242,7 +242,7 @@
mipsel->cp0_status = value++;
mipsel->cp0_cause = value++;
- for (size_t index = 0; index < arraysize(mipsel->fpregs.fregs); ++index) {
+ for (size_t index = 0; index < ArraySize(mipsel->fpregs.fregs); ++index) {
mipsel->fpregs.fregs[index]._fp_fregs = static_cast<float>(value++);
}
@@ -267,7 +267,7 @@
uint64_t value = seed;
- for (size_t index = 0; index < arraysize(mips64->regs); ++index) {
+ for (size_t index = 0; index < ArraySize(mips64->regs); ++index) {
mips64->regs[index] = value++;
}
@@ -278,7 +278,7 @@
mips64->cp0_status = value++;
mips64->cp0_cause = value++;
- for (size_t index = 0; index < arraysize(mips64->fpregs.dregs); ++index) {
+ for (size_t index = 0; index < ArraySize(mips64->fpregs.dregs); ++index) {
mips64->fpregs.dregs[index] = static_cast<double>(value++);
}
diff --git a/snapshot/win/cpu_context_win_test.cc b/snapshot/win/cpu_context_win_test.cc
index aa2afe9..7f66f9d 100644
--- a/snapshot/win/cpu_context_win_test.cc
+++ b/snapshot/win/cpu_context_win_test.cc
@@ -16,11 +16,11 @@
#include <windows.h>
-#include "base/macros.h"
#include "build/build_config.h"
#include "gtest/gtest.h"
-#include "test/hex_string.h"
#include "snapshot/cpu_context.h"
+#include "test/hex_string.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -87,13 +87,13 @@
for (size_t st_mm = 0; st_mm < 7; ++st_mm) {
EXPECT_EQ(
BytesToHexString(cpu_context_x86.fxsave.st_mm[st_mm].st,
- arraysize(cpu_context_x86.fxsave.st_mm[st_mm].st)),
- std::string(arraysize(cpu_context_x86.fxsave.st_mm[st_mm].st) * 2,
+ ArraySize(cpu_context_x86.fxsave.st_mm[st_mm].st)),
+ std::string(ArraySize(cpu_context_x86.fxsave.st_mm[st_mm].st) * 2,
'0'))
<< "st_mm " << st_mm;
}
EXPECT_EQ(BytesToHexString(cpu_context_x86.fxsave.st_mm[7].st,
- arraysize(cpu_context_x86.fxsave.st_mm[7].st)),
+ ArraySize(cpu_context_x86.fxsave.st_mm[7].st)),
"0000000000000080ff7f");
EXPECT_EQ(cpu_context_x86.dr0, 3u);
diff --git a/snapshot/win/crashpad_snapshot_test_image_reader.cc b/snapshot/win/crashpad_snapshot_test_image_reader.cc
index 4ebd98e..e6a9e5d 100644
--- a/snapshot/win/crashpad_snapshot_test_image_reader.cc
+++ b/snapshot/win/crashpad_snapshot_test_image_reader.cc
@@ -17,6 +17,7 @@
#include "base/logging.h"
#include "client/crashpad_info.h"
#include "util/file/file_io.h"
+#include "util/misc/arraysize.h"
#include "util/synchronization/semaphore.h"
#include "util/win/scoped_handle.h"
@@ -28,7 +29,7 @@
// Allocate a bunch of pointers to things on the stack.
int* pointers[1000];
- for (size_t i = 0; i < arraysize(pointers); ++i) {
+ for (size_t i = 0; i < ArraySize(pointers); ++i) {
pointers[i] = new int[2048];
}
@@ -52,7 +53,7 @@
// verify the cap on pointed-to memory.
crashpad::Semaphore semaphore(0);
crashpad::ScopedKernelHANDLE threads[100];
- for (size_t i = 0; i < arraysize(threads); ++i) {
+ for (size_t i = 0; i < ArraySize(threads); ++i) {
threads[i].reset(CreateThread(nullptr,
0,
&LotsOfReferencesThreadProc,
@@ -65,7 +66,7 @@
}
}
- for (size_t i = 0; i < arraysize(threads); ++i) {
+ for (size_t i = 0; i < ArraySize(threads); ++i) {
semaphore.Wait();
}
diff --git a/snapshot/win/pe_image_annotations_reader.cc b/snapshot/win/pe_image_annotations_reader.cc
index 4c1f66f..c5e5373 100644
--- a/snapshot/win/pe_image_annotations_reader.cc
+++ b/snapshot/win/pe_image_annotations_reader.cc
@@ -23,6 +23,7 @@
#include "snapshot/snapshot_constants.h"
#include "snapshot/win/pe_image_reader.h"
#include "snapshot/win/process_reader_win.h"
+#include "util/misc/arraysize.h"
#include "util/win/process_structs.h"
namespace crashpad {
@@ -155,7 +156,7 @@
snapshot.type = current.type;
char name[Annotation::kNameMaxLength];
- if (!process_reader_->Memory()->Read(current.name, arraysize(name), name)) {
+ if (!process_reader_->Memory()->Read(current.name, ArraySize(name), name)) {
LOG(WARNING) << "could not read annotation name at index " << index
<< " in " << base::UTF16ToUTF8(name_);
continue;
diff --git a/snapshot/win/pe_image_reader.cc b/snapshot/win/pe_image_reader.cc
index e705bb5..094cf0f 100644
--- a/snapshot/win/pe_image_reader.cc
+++ b/snapshot/win/pe_image_reader.cc
@@ -24,6 +24,7 @@
#include "base/strings/stringprintf.h"
#include "client/crashpad_info.h"
#include "snapshot/win/pe_image_resource_reader.h"
+#include "util/misc/arraysize.h"
#include "util/misc/from_pointer_cast.h"
#include "util/misc/pdb_structures.h"
#include "util/win/process_structs.h"
@@ -275,7 +276,7 @@
version_info.wType != 0 ||
wcsncmp(version_info.szKey,
L"VS_VERSION_INFO",
- arraysize(version_info.szKey)) != 0) {
+ ArraySize(version_info.szKey)) != 0) {
LOG(WARNING) << "unexpected VS_VERSIONINFO in "
<< module_subrange_reader_.name();
return false;
diff --git a/snapshot/win/process_reader_win_test.cc b/snapshot/win/process_reader_win_test.cc
index b0601e8..eca6f48 100644
--- a/snapshot/win/process_reader_win_test.cc
+++ b/snapshot/win/process_reader_win_test.cc
@@ -19,6 +19,7 @@
#include "gtest/gtest.h"
#include "test/win/win_multiprocess.h"
+#include "util/misc/arraysize.h"
#include "util/misc/from_pointer_cast.h"
#include "util/synchronization/semaphore.h"
#include "util/thread/thread.h"
@@ -43,7 +44,7 @@
EXPECT_EQ(process_reader.GetProcessInfo().ProcessID(), GetCurrentProcessId());
static constexpr char kTestMemory[] = "Some test memory";
- char buffer[arraysize(kTestMemory)];
+ char buffer[ArraySize(kTestMemory)];
ASSERT_TRUE(process_reader.Memory()->Read(
reinterpret_cast<uintptr_t>(kTestMemory), sizeof(kTestMemory), &buffer));
EXPECT_STREQ(kTestMemory, buffer);
@@ -184,7 +185,7 @@
// the pipe.
CheckedReadFileAtEOF(ReadPipeHandle());
- for (size_t i = 0; i < arraysize(threads); ++i)
+ for (size_t i = 0; i < ArraySize(threads); ++i)
done.Signal();
for (auto& thread : threads)
thread.Join();
diff --git a/snapshot/win/process_snapshot_win.cc b/snapshot/win/process_snapshot_win.cc
index 94dd22b..5d98a5f 100644
--- a/snapshot/win/process_snapshot_win.cc
+++ b/snapshot/win/process_snapshot_win.cc
@@ -24,6 +24,7 @@
#include "base/numerics/safe_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "build/build_config.h"
+#include "util/misc/arraysize.h"
#include "util/misc/from_pointer_cast.h"
#include "util/misc/time.h"
#include "util/win/nt_internals.h"
@@ -334,7 +335,7 @@
uet.TimeDateStamp,
base::UTF16ToUTF8(base::StringPiece16(
uet.ImageName,
- wcsnlen(uet.ImageName, arraysize(uet.ImageName))))));
+ wcsnlen(uet.ImageName, ArraySize(uet.ImageName))))));
}
}
}
@@ -534,9 +535,9 @@
env_block.resize(
static_cast<unsigned int>(bytes_read / sizeof(env_block[0])));
static constexpr wchar_t terminator[] = {0, 0};
- size_t at = env_block.find(std::wstring(terminator, arraysize(terminator)));
+ size_t at = env_block.find(std::wstring(terminator, ArraySize(terminator)));
if (at != std::wstring::npos)
- env_block.resize(at + arraysize(terminator));
+ env_block.resize(at + ArraySize(terminator));
return env_block.size() * sizeof(env_block[0]);
}
diff --git a/test/hex_string.h b/test/hex_string.h
index 435a692..2d7801b 100644
--- a/test/hex_string.h
+++ b/test/hex_string.h
@@ -29,8 +29,8 @@
//! uint8_t expected[10];
//! uint8_t observed[10];
//! // …
-//! EXPECT_EQ(BytesToHexString(observed, arraysize(observed)),
-//! BytesToHexString(expected, arraysize(expected)));
+//! EXPECT_EQ(BytesToHexString(observed, ArraySize(observed)),
+//! BytesToHexString(expected, ArraySize(expected)));
//! \endcode
std::string BytesToHexString(const void* bytes, size_t length);
diff --git a/test/hex_string_test.cc b/test/hex_string_test.cc
index 68745e6..3d44cc9 100644
--- a/test/hex_string_test.cc
+++ b/test/hex_string_test.cc
@@ -14,8 +14,8 @@
#include "test/hex_string.h"
-#include "base/macros.h"
#include "gtest/gtest.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -25,7 +25,7 @@
EXPECT_EQ(BytesToHexString(nullptr, 0), "");
static constexpr char kBytes[] = "Abc123xyz \x0a\x7f\xf0\x9f\x92\xa9_";
- EXPECT_EQ(BytesToHexString(kBytes, arraysize(kBytes)),
+ EXPECT_EQ(BytesToHexString(kBytes, ArraySize(kBytes)),
"41626331323378797a200a7ff09f92a95f00");
}
diff --git a/tools/crashpad_database_util.cc b/tools/crashpad_database_util.cc
index b4c2a15..d8274c5 100644
--- a/tools/crashpad_database_util.cc
+++ b/tools/crashpad_database_util.cc
@@ -28,7 +28,6 @@
#include "base/files/file_path.h"
#include "base/logging.h"
-#include "base/macros.h"
#include "base/numerics/safe_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "build/build_config.h"
@@ -37,6 +36,7 @@
#include "tools/tool_support.h"
#include "util/file/file_io.h"
#include "util/file/file_reader.h"
+#include "util/misc/arraysize.h"
#include "util/misc/uuid.h"
#include "util/stdlib/string_number_conversion.h"
@@ -109,14 +109,14 @@
"set",
};
- for (size_t index = 0; index < arraysize(kFalseWords); ++index) {
+ for (size_t index = 0; index < ArraySize(kFalseWords); ++index) {
if (strcasecmp(string, kFalseWords[index]) == 0) {
*boolean = false;
return true;
}
}
- for (size_t index = 0; index < arraysize(kTrueWords); ++index) {
+ for (size_t index = 0; index < ArraySize(kTrueWords); ++index) {
if (strcasecmp(string, kTrueWords[index]) == 0) {
*boolean = true;
return true;
@@ -159,7 +159,7 @@
"%+",
};
- for (size_t index = 0; index < arraysize(kFormats); ++index) {
+ for (size_t index = 0; index < ArraySize(kFormats); ++index) {
tm time_tm;
const char* strptime_result = strptime(string, kFormats[index], &time_tm);
if (strptime_result == end) {
@@ -214,7 +214,7 @@
char string[64];
CHECK_NE(
- strftime(string, arraysize(string), "%Y-%m-%d %H:%M:%S %Z", &time_tm),
+ strftime(string, ArraySize(string), "%Y-%m-%d %H:%M:%S %Z", &time_tm),
0u);
return std::string(string);
diff --git a/util/BUILD.gn b/util/BUILD.gn
index c7c6837..b5e1561 100644
--- a/util/BUILD.gn
+++ b/util/BUILD.gn
@@ -86,7 +86,7 @@
"file/string_file.h",
"misc/address_sanitizer.h",
"misc/address_types.h",
- "misc/arraysize_unsafe.h",
+ "misc/arraysize.h",
"misc/as_underlying_type.h",
"misc/capture_context.h",
"misc/clock.h",
@@ -530,7 +530,7 @@
"file/file_reader_test.cc",
"file/filesystem_test.cc",
"file/string_file_test.cc",
- "misc/arraysize_unsafe_test.cc",
+ "misc/arraysize_test.cc",
"misc/capture_context_test.cc",
"misc/capture_context_test_util.h",
"misc/clock_test.cc",
diff --git a/util/file/delimited_file_reader.cc b/util/file/delimited_file_reader.cc
index a55c2a7..2a8678f 100644
--- a/util/file/delimited_file_reader.cc
+++ b/util/file/delimited_file_reader.cc
@@ -21,6 +21,7 @@
#include "base/logging.h"
#include "base/numerics/safe_conversions.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
@@ -75,7 +76,7 @@
return Result::kEndOfFile;
}
- DCHECK_LE(static_cast<size_t>(read_result), arraysize(buf_));
+ DCHECK_LE(static_cast<size_t>(read_result), ArraySize(buf_));
DCHECK(
base::IsValueInRangeForNumericType<decltype(buf_len_)>(read_result));
buf_len_ = static_cast<decltype(buf_len_)>(read_result);
diff --git a/util/file/delimited_file_reader_test.cc b/util/file/delimited_file_reader_test.cc
index 79e331f..b226f3d 100644
--- a/util/file/delimited_file_reader_test.cc
+++ b/util/file/delimited_file_reader_test.cc
@@ -20,6 +20,7 @@
#include "base/strings/stringprintf.h"
#include "gtest/gtest.h"
#include "util/file/string_file.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -259,7 +260,7 @@
TEST(DelimitedFileReader, EmbeddedNUL) {
static constexpr char kString[] = "embedded\0NUL\n";
StringFile string_file;
- string_file.SetString(std::string(kString, arraysize(kString) - 1));
+ string_file.SetString(std::string(kString, ArraySize(kString) - 1));
DelimitedFileReader delimited_file_reader(&string_file);
std::string line;
@@ -277,7 +278,7 @@
TEST(DelimitedFileReader, NULDelimiter) {
static constexpr char kString[] = "aa\0b\0ccc\0";
StringFile string_file;
- string_file.SetString(std::string(kString, arraysize(kString) - 1));
+ string_file.SetString(std::string(kString, ArraySize(kString) - 1));
DelimitedFileReader delimited_file_reader(&string_file);
std::string field;
@@ -301,7 +302,7 @@
TEST(DelimitedFileReader, EdgeCases) {
static constexpr size_t kSizes[] =
{4094, 4095, 4096, 4097, 8190, 8191, 8192, 8193};
- for (size_t index = 0; index < arraysize(kSizes); ++index) {
+ for (size_t index = 0; index < ArraySize(kSizes); ++index) {
size_t size = kSizes[index];
SCOPED_TRACE(
base::StringPrintf("index %" PRIuS ", size %" PRIuS, index, size));
diff --git a/util/file/file_io_test.cc b/util/file/file_io_test.cc
index 4446c32..d341a5d 100644
--- a/util/file/file_io_test.cc
+++ b/util/file/file_io_test.cc
@@ -27,6 +27,7 @@
#include "test/errors.h"
#include "test/file.h"
#include "test/scoped_temp_dir.h"
+#include "util/misc/arraysize.h"
#include "util/misc/implicit_cast.h"
#include "util/thread/thread.h"
@@ -612,7 +613,7 @@
LockingTestThread threads[20];
int expected_iterations = 0;
- for (size_t index = 0; index < arraysize(threads); ++index) {
+ for (size_t index = 0; index < ArraySize(threads); ++index) {
int iterations_for_this_thread = static_cast<int>(index * 10);
threads[index].Init(
(other_locks == FileLocking::kShared)
diff --git a/util/linux/direct_ptrace_connection.cc b/util/linux/direct_ptrace_connection.cc
index ac44bf1..371bed2 100644
--- a/util/linux/direct_ptrace_connection.cc
+++ b/util/linux/direct_ptrace_connection.cc
@@ -22,6 +22,7 @@
#include "base/strings/string_number_conversions.h"
#include "util/file/directory_reader.h"
#include "util/file/file_io.h"
+#include "util/misc/arraysize.h"
#include "util/misc/as_underlying_type.h"
namespace crashpad {
@@ -92,7 +93,7 @@
DCHECK(threads->empty());
char path[32];
- snprintf(path, arraysize(path), "/proc/%d/task", pid_);
+ snprintf(path, ArraySize(path), "/proc/%d/task", pid_);
DirectoryReader reader;
if (!reader.Open(base::FilePath(path))) {
return false;
diff --git a/util/linux/proc_stat_reader.cc b/util/linux/proc_stat_reader.cc
index 795e513..60f1054 100644
--- a/util/linux/proc_stat_reader.cc
+++ b/util/linux/proc_stat_reader.cc
@@ -21,6 +21,7 @@
#include "base/files/file_path.h"
#include "base/logging.h"
#include "util/file/file_io.h"
+#include "util/misc/arraysize.h"
#include "util/misc/lexing.h"
#include "util/misc/time.h"
@@ -47,7 +48,7 @@
INITIALIZATION_STATE_SET_INITIALIZING(initialized_);
char path[32];
- snprintf(path, arraysize(path), "/proc/%d/stat", tid);
+ snprintf(path, ArraySize(path), "/proc/%d/stat", tid);
if (!connection->ReadFileContents(base::FilePath(path), &contents_)) {
return false;
}
diff --git a/util/linux/ptrace_client.cc b/util/linux/ptrace_client.cc
index 34fcbc3..e8afaa4 100644
--- a/util/linux/ptrace_client.cc
+++ b/util/linux/ptrace_client.cc
@@ -23,6 +23,7 @@
#include "base/strings/string_number_conversions.h"
#include "util/file/file_io.h"
#include "util/linux/ptrace_broker.h"
+#include "util/misc/arraysize.h"
#include "util/process/process_memory_linux.h"
namespace crashpad {
@@ -270,7 +271,7 @@
threads->push_back(pid_);
char path[32];
- snprintf(path, arraysize(path), "/proc/%d/task", pid_);
+ snprintf(path, ArraySize(path), "/proc/%d/task", pid_);
PtraceBroker::Request request;
request.type = PtraceBroker::Request::kTypeListDirectory;
diff --git a/util/mac/checked_mach_address_range_test.cc b/util/mac/checked_mach_address_range_test.cc
index 089f681..f2f8f54 100644
--- a/util/mac/checked_mach_address_range_test.cc
+++ b/util/mac/checked_mach_address_range_test.cc
@@ -19,10 +19,10 @@
#include <limits>
-#include "base/macros.h"
#include "base/strings/stringprintf.h"
#include "build/build_config.h"
#include "gtest/gtest.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -116,7 +116,7 @@
{0xffffffffffffffff, 1, kInvalid},
};
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
const auto& testcase = kTestData[index];
SCOPED_TRACE(base::StringPrintf("index %zu, base 0x%llx, size 0x%llx",
index,
@@ -166,7 +166,7 @@
CheckedMachAddressRange parent_range_32(false, 0x2000, 0x1000);
ASSERT_TRUE(parent_range_32.IsValid());
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
const auto& testcase = kTestData[index];
SCOPED_TRACE(
base::StringPrintf("index %zu, value 0x%llx", index, testcase.value));
@@ -223,7 +223,7 @@
CheckedMachAddressRange parent_range_32(false, 0x2000, 0x1000);
ASSERT_TRUE(parent_range_32.IsValid());
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
const auto& testcase = kTestData[index];
SCOPED_TRACE(base::StringPrintf("index %zu, base 0x%llx, size 0x%llx",
index,
diff --git a/util/mac/launchd_test.mm b/util/mac/launchd_test.mm
index 12ed832..4a6402d 100644
--- a/util/mac/launchd_test.mm
+++ b/util/mac/launchd_test.mm
@@ -23,8 +23,8 @@
#include <limits>
#include "base/mac/scoped_launch_data.h"
-#include "base/macros.h"
#include "gtest/gtest.h"
+#include "util/misc/arraysize.h"
#include "util/stdlib/objc.h"
namespace crashpad {
@@ -58,7 +58,7 @@
@0xfedcba9876543210,
};
- for (size_t index = 0; index < arraysize(integer_nses); ++index) {
+ for (size_t index = 0; index < ArraySize(integer_nses); ++index) {
NSNumber* integer_ns = integer_nses[index];
launch_data.reset(CFPropertyToLaunchData(integer_ns));
ASSERT_TRUE(launch_data.get());
@@ -88,7 +88,7 @@
[NSNumber numberWithDouble:std::numeric_limits<double>::signaling_NaN()],
};
- for (size_t index = 0; index < arraysize(double_nses); ++index) {
+ for (size_t index = 0; index < ArraySize(double_nses); ++index) {
NSNumber* double_ns = double_nses[index];
launch_data.reset(CFPropertyToLaunchData(double_ns));
ASSERT_TRUE(launch_data.get());
@@ -114,7 +114,7 @@
@YES,
};
- for (size_t index = 0; index < arraysize(bool_nses); ++index) {
+ for (size_t index = 0; index < ArraySize(bool_nses); ++index) {
NSNumber* bool_ns = bool_nses[index];
launch_data.reset(CFPropertyToLaunchData(bool_ns));
ASSERT_TRUE(launch_data.get());
@@ -138,7 +138,7 @@
@"Üñîçø∂é",
};
- for (size_t index = 0; index < arraysize(string_nses); ++index) {
+ for (size_t index = 0; index < ArraySize(string_nses); ++index) {
NSString* string_ns = string_nses[index];
launch_data.reset(CFPropertyToLaunchData(string_ns));
ASSERT_TRUE(launch_data.get());
diff --git a/util/mac/xattr.cc b/util/mac/xattr.cc
index 75d7938..c63fc87 100644
--- a/util/mac/xattr.cc
+++ b/util/mac/xattr.cc
@@ -20,7 +20,6 @@
#include <sys/xattr.h>
#include "base/logging.h"
-#include "base/macros.h"
#include "base/numerics/safe_conversions.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/stringprintf.h"
diff --git a/util/mach/child_port_handshake.cc b/util/mach/child_port_handshake.cc
index 750d3cb..721e560 100644
--- a/util/mach/child_port_handshake.cc
+++ b/util/mach/child_port_handshake.cc
@@ -38,6 +38,7 @@
#include "util/mach/mach_extensions.h"
#include "util/mach/mach_message.h"
#include "util/mach/mach_message_server.h"
+#include "util/misc/arraysize.h"
#include "util/misc/implicit_cast.h"
#include "util/misc/random_string.h"
@@ -158,7 +159,7 @@
0,
nullptr);
int rv = HANDLE_EINTR(
- kevent(kq.get(), changelist, arraysize(changelist), nullptr, 0, nullptr));
+ kevent(kq.get(), changelist, ArraySize(changelist), nullptr, 0, nullptr));
PCHECK(rv != -1) << "kevent";
ChildPortServer child_port_server(this);
diff --git a/util/mach/child_port_server.cc b/util/mach/child_port_server.cc
index a322302..678d3b2 100644
--- a/util/mach/child_port_server.cc
+++ b/util/mach/child_port_server.cc
@@ -17,6 +17,7 @@
#include "base/logging.h"
#include "util/mach/child_portServer.h"
#include "util/mach/mach_message.h"
+#include "util/misc/arraysize.h"
namespace {
@@ -90,7 +91,7 @@
static constexpr mach_msg_id_t request_ids[] =
{kMachMessageIDChildPortCheckIn};
return std::set<mach_msg_id_t>(&request_ids[0],
- &request_ids[arraysize(request_ids)]);
+ &request_ids[ArraySize(request_ids)]);
}
mach_msg_size_t ChildPortServer::MachMessageServerRequestSize() {
diff --git a/util/mach/composite_mach_message_server_test.cc b/util/mach/composite_mach_message_server_test.cc
index d45eca0..c2ed5d7 100644
--- a/util/mach/composite_mach_message_server_test.cc
+++ b/util/mach/composite_mach_message_server_test.cc
@@ -20,6 +20,7 @@
#include "gtest/gtest.h"
#include "test/gtest_death.h"
#include "util/mach/mach_message.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -196,7 +197,7 @@
TestMachMessageHandler handlers[3];
std::set<mach_msg_id_t> expect_request_ids;
- for (size_t index = 0; index < arraysize(kRequestIDs0); ++index) {
+ for (size_t index = 0; index < ArraySize(kRequestIDs0); ++index) {
const mach_msg_id_t request_id = kRequestIDs0[index];
handlers[0].AddRequestID(request_id);
expect_request_ids.insert(request_id);
@@ -205,7 +206,7 @@
handlers[0].SetReplySize(sizeof(mig_reply_error_t));
handlers[0].SetReturnCodes(true, kReturnCode0, false);
- for (size_t index = 0; index < arraysize(kRequestIDs1); ++index) {
+ for (size_t index = 0; index < ArraySize(kRequestIDs1); ++index) {
const mach_msg_id_t request_id = kRequestIDs1[index];
handlers[1].AddRequestID(request_id);
expect_request_ids.insert(request_id);
@@ -214,7 +215,7 @@
handlers[1].SetReplySize(200);
handlers[1].SetReturnCodes(false, kReturnCode1, true);
- for (size_t index = 0; index < arraysize(kRequestIDs2); ++index) {
+ for (size_t index = 0; index < ArraySize(kRequestIDs2); ++index) {
const mach_msg_id_t request_id = kRequestIDs2[index];
handlers[2].AddRequestID(request_id);
expect_request_ids.insert(request_id);
@@ -252,7 +253,7 @@
// Send messages with known request IDs.
- for (size_t index = 0; index < arraysize(kRequestIDs0); ++index) {
+ for (size_t index = 0; index < ArraySize(kRequestIDs0); ++index) {
request.header.msgh_id = kRequestIDs0[index];
SCOPED_TRACE(base::StringPrintf(
"handler 0, index %zu, id %d", index, request.header.msgh_id));
@@ -263,7 +264,7 @@
EXPECT_FALSE(destroy_complex_request);
}
- for (size_t index = 0; index < arraysize(kRequestIDs1); ++index) {
+ for (size_t index = 0; index < ArraySize(kRequestIDs1); ++index) {
request.header.msgh_id = kRequestIDs1[index];
SCOPED_TRACE(base::StringPrintf(
"handler 1, index %zu, id %d", index, request.header.msgh_id));
@@ -274,7 +275,7 @@
EXPECT_TRUE(destroy_complex_request);
}
- for (size_t index = 0; index < arraysize(kRequestIDs2); ++index) {
+ for (size_t index = 0; index < ArraySize(kRequestIDs2); ++index) {
request.header.msgh_id = kRequestIDs2[index];
SCOPED_TRACE(base::StringPrintf(
"handler 2, index %zu, id %d", index, request.header.msgh_id));
diff --git a/util/mach/exc_client_variants_test.cc b/util/mach/exc_client_variants_test.cc
index b728856..7d1d00d 100644
--- a/util/mach/exc_client_variants_test.cc
+++ b/util/mach/exc_client_variants_test.cc
@@ -29,6 +29,7 @@
#include "util/mach/mach_extensions.h"
#include "util/mach/mach_message.h"
#include "util/mach/mach_message_server.h"
+#include "util/misc/arraysize.h"
#include "util/misc/implicit_cast.h"
namespace crashpad {
@@ -181,11 +182,11 @@
// These aren’t real flavors, it’s just for testing.
flavor = exception_ + 10;
flavor_p = &flavor;
- for (size_t index = 0; index < arraysize(old_state); ++index) {
+ for (size_t index = 0; index < ArraySize(old_state); ++index) {
old_state[index] = index;
}
old_state_p = reinterpret_cast<thread_state_t>(&old_state);
- old_state_count = arraysize(old_state);
+ old_state_count = ArraySize(old_state);
// new_state and new_state_count are out parameters that the server should
// never see or use, so set them to bogus values. The call to the server
@@ -202,7 +203,7 @@
task,
exception,
code,
- arraysize(code),
+ ArraySize(code),
flavor_p,
old_state_p,
old_state_count,
@@ -273,7 +274,7 @@
kMachExceptionCodes | EXCEPTION_STATE_IDENTITY,
};
- for (size_t index = 0; index < arraysize(kBehaviors); ++index) {
+ for (size_t index = 0; index < ArraySize(kBehaviors); ++index) {
exception_behavior_t behavior = kBehaviors[index];
SCOPED_TRACE(base::StringPrintf("index %zu, behavior %d", index, behavior));
diff --git a/util/mach/exc_server_variants.cc b/util/mach/exc_server_variants.cc
index e7174ac..f7b0b3d 100644
--- a/util/mach/exc_server_variants.cc
+++ b/util/mach/exc_server_variants.cc
@@ -29,6 +29,7 @@
#include "util/mach/mach_exc.h"
#include "util/mach/mach_excServer.h"
#include "util/mach/mach_message.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
@@ -242,7 +243,7 @@
Traits::kMachMessageIDExceptionRaiseStateIdentity,
};
return std::set<mach_msg_id_t>(&request_ids[0],
- &request_ids[arraysize(request_ids)]);
+ &request_ids[ArraySize(request_ids)]);
}
mach_msg_size_t MachMessageServerRequestSize() override {
@@ -319,7 +320,7 @@
using Reply = typename Traits::ExceptionRaiseStateReply;
Reply* out_reply = reinterpret_cast<Reply*>(out_header);
out_reply->flavor = in_request_1->flavor;
- out_reply->new_stateCnt = arraysize(out_reply->new_state);
+ out_reply->new_stateCnt = ArraySize(out_reply->new_state);
out_reply->RetCode =
interface_->CatchExceptionRaiseState(in_header->msgh_local_port,
in_request->exception,
@@ -362,7 +363,7 @@
using Reply = typename Traits::ExceptionRaiseStateIdentityReply;
Reply* out_reply = reinterpret_cast<Reply*>(out_header);
out_reply->flavor = in_request_1->flavor;
- out_reply->new_stateCnt = arraysize(out_reply->new_state);
+ out_reply->new_stateCnt = ArraySize(out_reply->new_state);
out_reply->RetCode = interface_->CatchExceptionRaiseStateIdentity(
in_header->msgh_local_port,
in_request->thread.name,
diff --git a/util/mach/exc_server_variants_test.cc b/util/mach/exc_server_variants_test.cc
index 5e67bfe..b50ded1 100644
--- a/util/mach/exc_server_variants_test.cc
+++ b/util/mach/exc_server_variants_test.cc
@@ -29,6 +29,7 @@
#include "util/mach/exception_behaviors.h"
#include "util/mach/exception_types.h"
#include "util/mach/mach_message.h"
+#include "util/misc/arraysize.h"
#include "util/misc/implicit_cast.h"
namespace crashpad {
@@ -228,7 +229,7 @@
EXPECT_EQ(memcmp(&NDR, &NDR_record, sizeof(NDR)), 0);
EXPECT_EQ(RetCode, KERN_SUCCESS);
EXPECT_EQ(flavor, kThreadStateFlavor);
- EXPECT_EQ(new_stateCnt, arraysize(new_state));
+ EXPECT_EQ(new_stateCnt, ArraySize(new_state));
}
mach_msg_header_t Head;
@@ -659,7 +660,7 @@
AreExceptionCodes(kTestExceptonCodes[0], kTestExceptonCodes[1]),
Pointee(Eq(kThreadStateFlavor)),
IsThreadStateAndCount(kThreadStateFlavorCount),
- IsThreadStateAndCount(arraysize(reply.new_state)),
+ IsThreadStateAndCount(ArraySize(reply.new_state)),
Eq(request.Trailer())))
.WillOnce(Return(KERN_SUCCESS))
.RetiresOnSaturation();
@@ -708,7 +709,7 @@
AreExceptionCodes(kTestExceptonCodes[0], kTestExceptonCodes[1]),
Pointee(Eq(kThreadStateFlavor)),
IsThreadStateAndCount(kThreadStateFlavorCount),
- IsThreadStateAndCount(arraysize(reply.new_state)),
+ IsThreadStateAndCount(ArraySize(reply.new_state)),
Eq(request.Trailer())))
.WillOnce(Return(KERN_SUCCESS))
.RetiresOnSaturation();
@@ -802,7 +803,7 @@
kTestMachExceptionCodes[1]),
Pointee(Eq(kThreadStateFlavor)),
IsThreadStateAndCount(kThreadStateFlavorCount),
- IsThreadStateAndCount(arraysize(reply.new_state)),
+ IsThreadStateAndCount(ArraySize(reply.new_state)),
Eq(request.Trailer())))
.WillOnce(Return(KERN_SUCCESS))
.RetiresOnSaturation();
@@ -852,7 +853,7 @@
kTestMachExceptionCodes[1]),
Pointee(Eq(kThreadStateFlavor)),
IsThreadStateAndCount(kThreadStateFlavorCount),
- IsThreadStateAndCount(arraysize(reply.new_state)),
+ IsThreadStateAndCount(ArraySize(reply.new_state)),
Eq(request.Trailer())))
.WillOnce(Return(KERN_SUCCESS))
.RetiresOnSaturation();
@@ -906,7 +907,7 @@
2508,
};
- for (size_t index = 0; index < arraysize(unknown_ids); ++index) {
+ for (size_t index = 0; index < ArraySize(unknown_ids); ++index) {
mach_msg_id_t id = unknown_ids[index];
SCOPED_TRACE(base::StringPrintf("unknown id %d", id));
@@ -1179,7 +1180,7 @@
#endif
};
- for (size_t index = 0; index < arraysize(test_data); ++index) {
+ for (size_t index = 0; index < ArraySize(test_data); ++index) {
const auto& test = test_data[index];
SCOPED_TRACE(
base::StringPrintf("index %zu, flavor %d", index, test.flavor));
@@ -1252,7 +1253,7 @@
KERN_SUCCESS},
};
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
const auto& test_data = kTestData[index];
SCOPED_TRACE(
base::StringPrintf("index %zu, behavior %d, set_thread_state %s",
@@ -1271,8 +1272,8 @@
static constexpr natural_t old_state[] = {1, 2, 3, 4, 5};
natural_t new_state[10] = {};
- constexpr mach_msg_type_number_t old_state_count = arraysize(old_state);
- mach_msg_type_number_t new_state_count = arraysize(new_state);
+ constexpr mach_msg_type_number_t old_state_count = ArraySize(old_state);
+ mach_msg_type_number_t new_state_count = ArraySize(new_state);
// EXCEPTION_DEFAULT (with or without MACH_EXCEPTION_CODES) is not
// state-carrying. new_state and new_state_count should be untouched.
@@ -1281,8 +1282,8 @@
old_state_count,
new_state,
&new_state_count);
- EXPECT_EQ(new_state_count, arraysize(new_state));
- for (size_t i = 0; i < arraysize(new_state); ++i) {
+ EXPECT_EQ(new_state_count, ArraySize(new_state));
+ for (size_t i = 0; i < ArraySize(new_state); ++i) {
EXPECT_EQ(new_state[i], 0u) << "i " << i;
}
@@ -1291,8 +1292,8 @@
old_state_count,
new_state,
&new_state_count);
- EXPECT_EQ(new_state_count, arraysize(new_state));
- for (size_t i = 0; i < arraysize(new_state); ++i) {
+ EXPECT_EQ(new_state_count, ArraySize(new_state));
+ for (size_t i = 0; i < ArraySize(new_state); ++i) {
EXPECT_EQ(new_state[i], 0u) << "i " << i;
}
@@ -1304,7 +1305,7 @@
for (size_t i = 0; i < copy_limit; ++i) {
EXPECT_EQ(new_state[i], old_state[i]) << "i " << i;
}
- for (size_t i = copy_limit; i < arraysize(new_state); ++i) {
+ for (size_t i = copy_limit; i < ArraySize(new_state); ++i) {
EXPECT_EQ(new_state[i], 0u) << "i " << i;
}
@@ -1320,23 +1321,23 @@
for (size_t i = 0; i < copy_limit; ++i) {
EXPECT_EQ(new_state[i], old_state[i]) << "i " << i;
}
- for (size_t i = copy_limit; i < arraysize(new_state); ++i) {
+ for (size_t i = copy_limit; i < ArraySize(new_state); ++i) {
EXPECT_EQ(new_state[i], 0u) << "i " << i;
}
// This is a state-carrying exception where all of old_state is copied to
// new_state, which is large enough to receive it and then some.
- new_state_count = arraysize(new_state);
+ new_state_count = ArraySize(new_state);
ExcServerCopyState(MACH_EXCEPTION_CODES | EXCEPTION_STATE_IDENTITY,
old_state,
old_state_count,
new_state,
&new_state_count);
EXPECT_EQ(new_state_count, old_state_count);
- for (size_t i = 0; i < arraysize(old_state); ++i) {
+ for (size_t i = 0; i < ArraySize(old_state); ++i) {
EXPECT_EQ(new_state[i], old_state[i]) << "i " << i;
}
- for (size_t i = arraysize(old_state); i < arraysize(new_state); ++i) {
+ for (size_t i = ArraySize(old_state); i < ArraySize(new_state); ++i) {
EXPECT_EQ(new_state[i], 0u) << "i " << i;
}
}
diff --git a/util/mach/exception_behaviors_test.cc b/util/mach/exception_behaviors_test.cc
index d45110d..fd74d22 100644
--- a/util/mach/exception_behaviors_test.cc
+++ b/util/mach/exception_behaviors_test.cc
@@ -16,10 +16,10 @@
#include <sys/types.h>
-#include "base/macros.h"
#include "base/strings/stringprintf.h"
#include "gtest/gtest.h"
#include "util/mach/mach_extensions.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -53,7 +53,7 @@
EXCEPTION_STATE_IDENTITY},
};
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
const auto& test_data = kTestData[index];
SCOPED_TRACE(base::StringPrintf(
"index %zu, behavior %d", index, test_data.behavior));
diff --git a/util/mach/exception_types_test.cc b/util/mach/exception_types_test.cc
index c24428a..030c7f3 100644
--- a/util/mach/exception_types_test.cc
+++ b/util/mach/exception_types_test.cc
@@ -20,11 +20,11 @@
#include <sys/types.h>
#include <unistd.h>
-#include "base/macros.h"
#include "base/strings/stringprintf.h"
#include "gtest/gtest.h"
#include "util/mac/mac_util.h"
#include "util/mach/mach_extensions.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -67,7 +67,7 @@
{0, 0, 0, 0},
};
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
const auto& test_data = kTestData[index];
SCOPED_TRACE(base::StringPrintf(
"index %zu, code_0 0x%llx", index, test_data.code_0));
@@ -84,7 +84,7 @@
// Now make sure that ExcCrashRecoverOriginalException() properly ignores
// optional arguments.
- static_assert(arraysize(kTestData) >= 1, "must have something to test");
+ static_assert(ArraySize(kTestData) >= 1, "must have something to test");
const auto& test_data = kTestData[0];
EXPECT_EQ(
ExcCrashRecoverOriginalException(test_data.code_0, nullptr, nullptr),
@@ -238,7 +238,7 @@
{0x00010000, 0x00010000, static_cast<int32_t>(0xffffffff)},
};
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
const auto& test_data = kTestData[index];
SCOPED_TRACE(base::StringPrintf("index %zu, exception 0x%x, code_0 0x%llx",
index,
diff --git a/util/mach/mach_message_server_test.cc b/util/mach/mach_message_server_test.cc
index 16ba8f2..724d84e 100644
--- a/util/mach/mach_message_server_test.cc
+++ b/util/mach/mach_message_server_test.cc
@@ -29,6 +29,7 @@
#include "util/file/file_io.h"
#include "util/mach/mach_extensions.h"
#include "util/mach/mach_message.h"
+#include "util/misc/arraysize.h"
#include "util/misc/implicit_cast.h"
namespace crashpad {
@@ -281,7 +282,7 @@
std::set<mach_msg_id_t> MachMessageServerRequestIDs() override {
static constexpr mach_msg_id_t request_ids[] = {kRequestMessageID};
return std::set<mach_msg_id_t>(&request_ids[0],
- &request_ids[arraysize(request_ids)]);
+ &request_ids[ArraySize(request_ids)]);
}
mach_msg_size_t MachMessageServerRequestSize() override {
diff --git a/util/mach/mach_message_test.cc b/util/mach/mach_message_test.cc
index d88ca85..b00b187 100644
--- a/util/mach/mach_message_test.cc
+++ b/util/mach/mach_message_test.cc
@@ -17,6 +17,7 @@
#include <unistd.h>
#include "base/mac/scoped_mach_port.h"
+#include "base/macros.h"
#include "gtest/gtest.h"
#include "test/mac/mach_errors.h"
#include "util/mach/mach_extensions.h"
diff --git a/util/mach/notify_server.cc b/util/mach/notify_server.cc
index 711529b..5d0b3c0 100644
--- a/util/mach/notify_server.cc
+++ b/util/mach/notify_server.cc
@@ -17,6 +17,7 @@
#include "base/logging.h"
#include "util/mach/mach_message.h"
#include "util/mach/notifyServer.h"
+#include "util/misc/arraysize.h"
namespace {
@@ -227,7 +228,7 @@
MACH_NOTIFY_DEAD_NAME,
};
return std::set<mach_msg_id_t>(&request_ids[0],
- &request_ids[arraysize(request_ids)]);
+ &request_ids[ArraySize(request_ids)]);
}
mach_msg_size_t NotifyServer::MachMessageServerRequestSize() {
diff --git a/util/mach/symbolic_constants_mach.cc b/util/mach/symbolic_constants_mach.cc
index 98a2d20..fa6eefb 100644
--- a/util/mach/symbolic_constants_mach.cc
+++ b/util/mach/symbolic_constants_mach.cc
@@ -17,10 +17,10 @@
#include <string.h>
#include <sys/types.h>
-#include "base/macros.h"
#include "base/strings/stringprintf.h"
#include "util/mach/exception_behaviors.h"
#include "util/mach/mach_extensions.h"
+#include "util/misc/arraysize.h"
#include "util/misc/implicit_cast.h"
#include "util/stdlib/string_number_conversion.h"
@@ -45,7 +45,7 @@
"GUARD",
"CORPSE_NOTIFY",
};
-static_assert(arraysize(kExceptionNames) == EXC_TYPES_COUNT,
+static_assert(ArraySize(kExceptionNames) == EXC_TYPES_COUNT,
"kExceptionNames length");
constexpr char kExcPrefix[] = "EXC_";
@@ -170,8 +170,7 @@
{"_STATE32", "32"},
{"_STATE64", "64"},
};
- for (size_t suffix_index = 0;
- suffix_index < arraysize(kStateSuffixes);
+ for (size_t suffix_index = 0; suffix_index < ArraySize(kStateSuffixes);
++suffix_index) {
const char* suffix = kStateSuffixes[suffix_index].orig;
size_t suffix_len = strlen(suffix);
@@ -195,7 +194,7 @@
std::string ExceptionToString(exception_type_t exception,
SymbolicConstantToStringOptions options) {
const char* exception_name =
- implicit_cast<size_t>(exception) < arraysize(kExceptionNames)
+ implicit_cast<size_t>(exception) < ArraySize(kExceptionNames)
? kExceptionNames[exception]
: nullptr;
if (!exception_name) {
@@ -221,7 +220,7 @@
base::StringPiece short_string =
can_match_full ? string.substr(strlen(kExcPrefix)) : string;
for (exception_type_t index = 0;
- index < implicit_cast<exception_type_t>(arraysize(kExceptionNames));
+ index < implicit_cast<exception_type_t>(ArraySize(kExceptionNames));
++index) {
const char* exception_name = kExceptionNames[index];
if (!exception_name) {
@@ -251,8 +250,7 @@
exception_mask_t local_exception_mask = exception_mask;
std::string mask_string;
bool has_forbidden_or = false;
- for (size_t exception = 0;
- exception < arraysize(kExceptionNames);
+ for (size_t exception = 0; exception < ArraySize(kExceptionNames);
++exception) {
const char* exception_name = kExceptionNames[exception];
exception_mask_t exception_mask_value = 1 << exception;
@@ -326,7 +324,7 @@
base::StringPiece short_string =
can_match_full ? string.substr(strlen(kExcMaskPrefix)) : string;
for (exception_type_t index = 0;
- index < implicit_cast<exception_type_t>(arraysize(kExceptionNames));
+ index < implicit_cast<exception_type_t>(ArraySize(kExceptionNames));
++index) {
const char* exception_name = kExceptionNames[index];
if (!exception_name) {
@@ -365,7 +363,7 @@
const exception_behavior_t basic_behavior = ExceptionBehaviorBasic(behavior);
const char* behavior_name =
- implicit_cast<size_t>(basic_behavior) < arraysize(kBehaviorNames)
+ implicit_cast<size_t>(basic_behavior) < ArraySize(kBehaviorNames)
? kBehaviorNames[basic_behavior]
: nullptr;
if (!behavior_name) {
@@ -432,7 +430,7 @@
base::StringPiece short_string =
can_match_full ? sp.substr(strlen(kBehaviorPrefix)) : sp;
for (exception_behavior_t index = 0;
- index < implicit_cast<exception_behavior_t>(arraysize(kBehaviorNames));
+ index < implicit_cast<exception_behavior_t>(ArraySize(kBehaviorNames));
++index) {
const char* behavior_name = kBehaviorNames[index];
if (!behavior_name) {
@@ -468,13 +466,13 @@
std::string ThreadStateFlavorToString(thread_state_flavor_t flavor,
SymbolicConstantToStringOptions options) {
const char* flavor_name =
- implicit_cast<size_t>(flavor) < arraysize(kFlavorNames)
+ implicit_cast<size_t>(flavor) < ArraySize(kFlavorNames)
? kFlavorNames[flavor]
: nullptr;
if (!flavor_name) {
for (size_t generic_flavor_index = 0;
- generic_flavor_index < arraysize(kGenericFlavorNames);
+ generic_flavor_index < ArraySize(kGenericFlavorNames);
++generic_flavor_index) {
if (flavor == kGenericFlavorNames[generic_flavor_index].flavor) {
flavor_name = kGenericFlavorNames[generic_flavor_index].name;
@@ -501,7 +499,7 @@
thread_state_flavor_t* flavor) {
if ((options & kAllowFullName) || (options & kAllowShortName)) {
for (thread_state_flavor_t index = 0;
- index < implicit_cast<thread_state_flavor_t>(arraysize(kFlavorNames));
+ index < implicit_cast<thread_state_flavor_t>(ArraySize(kFlavorNames));
++index) {
const char* flavor_name = kFlavorNames[index];
if (!flavor_name) {
@@ -521,7 +519,7 @@
}
for (size_t generic_flavor_index = 0;
- generic_flavor_index < arraysize(kGenericFlavorNames);
+ generic_flavor_index < ArraySize(kGenericFlavorNames);
++generic_flavor_index) {
const char* flavor_name = kGenericFlavorNames[generic_flavor_index].name;
thread_state_flavor_t flavor_number =
diff --git a/util/mach/symbolic_constants_mach_test.cc b/util/mach/symbolic_constants_mach_test.cc
index 3bf5abb..4856f0a 100644
--- a/util/mach/symbolic_constants_mach_test.cc
+++ b/util/mach/symbolic_constants_mach_test.cc
@@ -18,14 +18,15 @@
#include <string.h>
#include <sys/types.h>
-#include "base/macros.h"
#include "base/strings/string_piece.h"
#include "base/strings/stringprintf.h"
#include "gtest/gtest.h"
#include "util/mach/mach_extensions.h"
+#include "util/misc/arraysize.h"
#include "util/misc/implicit_cast.h"
-#define NUL_TEST_DATA(string) { string, arraysize(string) - 1 }
+#define NUL_TEST_DATA(string) \
+ { string, ArraySize(string) - 1 }
namespace crashpad {
namespace test {
@@ -159,7 +160,7 @@
}
TEST(SymbolicConstantsMach, ExceptionToString) {
- for (size_t index = 0; index < arraysize(kExceptionTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kExceptionTestData); ++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
TestExceptionToString(kExceptionTestData[index].exception,
kExceptionTestData[index].full_name,
@@ -187,12 +188,11 @@
}
TEST(SymbolicConstantsMach, StringToException) {
- for (size_t option_index = 0;
- option_index < arraysize(kNormalOptions);
+ for (size_t option_index = 0; option_index < ArraySize(kNormalOptions);
++option_index) {
SCOPED_TRACE(base::StringPrintf("option_index %zu", option_index));
StringToSymbolicConstantOptions options = kNormalOptions[option_index];
- for (size_t index = 0; index < arraysize(kExceptionTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kExceptionTestData); ++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
exception_type_t exception = kExceptionTestData[index].exception;
{
@@ -230,7 +230,7 @@
"",
};
- for (size_t index = 0; index < arraysize(kNegativeTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kNegativeTestData); ++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
TestStringToException(kNegativeTestData[index], options, false, 0);
}
@@ -251,7 +251,7 @@
NUL_TEST_DATA("1\0002"),
};
- for (size_t index = 0; index < arraysize(kNULTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kNULTestData); ++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
base::StringPiece string(kNULTestData[index].string,
kNULTestData[index].length);
@@ -334,7 +334,7 @@
}
TEST(SymbolicConstantsMach, ExceptionMaskToString) {
- for (size_t index = 0; index < arraysize(kExceptionMaskTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kExceptionMaskTestData); ++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
TestExceptionMaskToString(kExceptionMaskTestData[index].exception_mask,
kExceptionMaskTestData[index].full_name,
@@ -389,12 +389,11 @@
kAllowFullName | kAllowShortName | kAllowNumber | kAllowOr,
};
- for (size_t option_index = 0;
- option_index < arraysize(kOptions);
+ for (size_t option_index = 0; option_index < ArraySize(kOptions);
++option_index) {
SCOPED_TRACE(base::StringPrintf("option_index %zu", option_index));
StringToSymbolicConstantOptions options = kOptions[option_index];
- for (size_t index = 0; index < arraysize(kExceptionMaskTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kExceptionMaskTestData); ++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
exception_mask_t exception_mask =
kExceptionMaskTestData[index].exception_mask;
@@ -445,7 +444,7 @@
"",
};
- for (size_t index = 0; index < arraysize(kNegativeTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kNegativeTestData); ++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
TestStringToExceptionMask(kNegativeTestData[index], options, false, 0);
}
@@ -471,7 +470,7 @@
NUL_TEST_DATA("ARITHMETIC|\0EMULATION"),
};
- for (size_t index = 0; index < arraysize(kNULTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kNULTestData); ++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
base::StringPiece string(kNULTestData[index].string,
kNULTestData[index].length);
@@ -506,7 +505,7 @@
EXC_MASK_SYSCALL | 0x100},
};
- for (size_t index = 0; index < arraysize(kNonCanonicalTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kNonCanonicalTestData); ++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
TestStringToExceptionMask(kNonCanonicalTestData[index].string,
kNonCanonicalTestData[index].options,
@@ -577,8 +576,7 @@
}
TEST(SymbolicConstantsMach, ExceptionBehaviorToString) {
- for (size_t index = 0;
- index < arraysize(kExceptionBehaviorTestData);
+ for (size_t index = 0; index < ArraySize(kExceptionBehaviorTestData);
++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
TestExceptionBehaviorToString(kExceptionBehaviorTestData[index].behavior,
@@ -608,13 +606,11 @@
}
TEST(SymbolicConstantsMach, StringToExceptionBehavior) {
- for (size_t option_index = 0;
- option_index < arraysize(kNormalOptions);
+ for (size_t option_index = 0; option_index < ArraySize(kNormalOptions);
++option_index) {
SCOPED_TRACE(base::StringPrintf("option_index %zu", option_index));
StringToSymbolicConstantOptions options = kNormalOptions[option_index];
- for (size_t index = 0;
- index < arraysize(kExceptionBehaviorTestData);
+ for (size_t index = 0; index < ArraySize(kExceptionBehaviorTestData);
++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
exception_behavior_t behavior =
@@ -660,7 +656,7 @@
"",
};
- for (size_t index = 0; index < arraysize(kNegativeTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kNegativeTestData); ++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
TestStringToExceptionBehavior(
kNegativeTestData[index], options, false, 0);
@@ -686,7 +682,7 @@
NUL_TEST_DATA("STATE_IDENTITY|\0MACH"),
};
- for (size_t index = 0; index < arraysize(kNULTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kNULTestData); ++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
base::StringPiece string(kNULTestData[index].string,
kNULTestData[index].length);
@@ -723,7 +719,7 @@
implicit_cast<exception_behavior_t>(MACH_EXCEPTION_CODES | 0x2)},
};
- for (size_t index = 0; index < arraysize(kNonCanonicalTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kNonCanonicalTestData); ++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
TestStringToExceptionBehavior(kNonCanonicalTestData[index].string,
kNonCanonicalTestData[index].options,
@@ -840,8 +836,7 @@
}
TEST(SymbolicConstantsMach, ThreadStateFlavorToString) {
- for (size_t index = 0;
- index < arraysize(kThreadStateFlavorTestData);
+ for (size_t index = 0; index < ArraySize(kThreadStateFlavorTestData);
++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
TestThreadStateFlavorToString(kThreadStateFlavorTestData[index].flavor,
@@ -883,13 +878,11 @@
}
TEST(SymbolicConstantsMach, StringToThreadStateFlavor) {
- for (size_t option_index = 0;
- option_index < arraysize(kNormalOptions);
+ for (size_t option_index = 0; option_index < ArraySize(kNormalOptions);
++option_index) {
SCOPED_TRACE(base::StringPrintf("option_index %zu", option_index));
StringToSymbolicConstantOptions options = kNormalOptions[option_index];
- for (size_t index = 0;
- index < arraysize(kThreadStateFlavorTestData);
+ for (size_t index = 0; index < ArraySize(kThreadStateFlavorTestData);
++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
thread_state_flavor_t flavor = kThreadStateFlavorTestData[index].flavor;
@@ -959,7 +952,7 @@
#endif
};
- for (size_t index = 0; index < arraysize(kNegativeTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kNegativeTestData); ++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
TestStringToThreadStateFlavor(
kNegativeTestData[index], options, false, 0);
@@ -1025,7 +1018,7 @@
#endif
};
- for (size_t index = 0; index < arraysize(kNULTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kNULTestData); ++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
base::StringPiece string(kNULTestData[index].string,
kNULTestData[index].length);
diff --git a/util/misc/arraysize.h b/util/misc/arraysize.h
new file mode 100644
index 0000000..d476edb
--- /dev/null
+++ b/util/misc/arraysize.h
@@ -0,0 +1,39 @@
+// Copyright 2019 The Crashpad Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef CRASHPAD_UTIL_MISC_ARRAYSIZE_H_
+#define CRASHPAD_UTIL_MISC_ARRAYSIZE_H_
+
+#include <sys/types.h> // For size_t.
+
+#include <type_traits>
+
+//! \file
+
+namespace crashpad {
+namespace internal {
+
+//! \brief A helper to implement ArraySize.
+template <typename ArrayType>
+constexpr size_t ArraySizeHelper() noexcept {
+ return std::extent<typename std::remove_reference<ArrayType>::type>::value;
+}
+
+} // namespace internal
+} // namespace crashpad
+
+//! \brief A way of computing an array’s size.
+#define ArraySize(array) crashpad::internal::ArraySizeHelper<decltype(array)>()
+
+#endif // CRASHPAD_UTIL_MISC_ARRAYSIZE_H_
diff --git a/util/misc/arraysize_unsafe_test.cc b/util/misc/arraysize_test.cc
similarity index 68%
rename from util/misc/arraysize_unsafe_test.cc
rename to util/misc/arraysize_test.cc
index a6660ae..ad8da09 100644
--- a/util/misc/arraysize_unsafe_test.cc
+++ b/util/misc/arraysize_test.cc
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-#include "util/misc/arraysize_unsafe.h"
+#include "util/misc/arraysize.h"
#include "base/compiler_specific.h"
#include "gtest/gtest.h"
@@ -21,37 +21,37 @@
namespace test {
namespace {
-TEST(ArraySizeUnsafe, ArraySizeUnsafe) {
+TEST(ArraySize, ArraySize) {
char c1[1];
- static_assert(ARRAYSIZE_UNSAFE(c1) == 1, "c1");
+ static_assert(ArraySize(c1) == 1, "c1");
ALLOW_UNUSED_LOCAL(c1);
char c2[2];
- static_assert(ARRAYSIZE_UNSAFE(c2) == 2, "c2");
+ static_assert(ArraySize(c2) == 2, "c2");
ALLOW_UNUSED_LOCAL(c2);
char c4[4];
- static_assert(ARRAYSIZE_UNSAFE(c4) == 4, "c4");
+ static_assert(ArraySize(c4) == 4, "c4");
ALLOW_UNUSED_LOCAL(c4);
int i1[1];
- static_assert(ARRAYSIZE_UNSAFE(i1) == 1, "i1");
+ static_assert(ArraySize(i1) == 1, "i1");
ALLOW_UNUSED_LOCAL(i1);
int i2[2];
- static_assert(ARRAYSIZE_UNSAFE(i2) == 2, "i2");
+ static_assert(ArraySize(i2) == 2, "i2");
ALLOW_UNUSED_LOCAL(i2);
int i4[4];
- static_assert(ARRAYSIZE_UNSAFE(i4) == 4, "i4");
+ static_assert(ArraySize(i4) == 4, "i4");
ALLOW_UNUSED_LOCAL(i4);
long l8[8];
- static_assert(ARRAYSIZE_UNSAFE(l8) == 8, "l8");
+ static_assert(ArraySize(l8) == 8, "l8");
ALLOW_UNUSED_LOCAL(l8);
int l9[9];
- static_assert(ARRAYSIZE_UNSAFE(l9) == 9, "l9");
+ static_assert(ArraySize(l9) == 9, "l9");
ALLOW_UNUSED_LOCAL(l9);
struct S {
@@ -62,11 +62,11 @@
};
S s1[1];
- static_assert(ARRAYSIZE_UNSAFE(s1) == 1, "s1");
+ static_assert(ArraySize(s1) == 1, "s1");
ALLOW_UNUSED_LOCAL(s1);
S s10[10];
- static_assert(ARRAYSIZE_UNSAFE(s10) == 10, "s10");
+ static_assert(ArraySize(s10) == 10, "s10");
ALLOW_UNUSED_LOCAL(s10);
}
diff --git a/util/misc/arraysize_unsafe.h b/util/misc/arraysize_unsafe.h
deleted file mode 100644
index e53c70b..0000000
--- a/util/misc/arraysize_unsafe.h
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2016 The Crashpad Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef CRASHPAD_UTIL_MISC_ARRAYSIZE_UNSAFE_H_
-#define CRASHPAD_UTIL_MISC_ARRAYSIZE_UNSAFE_H_
-
-//! \file
-
-//! \brief Not the safest way of computing an array’s size…
-//!
-//! `#%include "base/macros.h"` and use its `arraysize()` instead. This macro
-//! should only be used in rare situations where `arraysize()` does not
-//! function.
-#define ARRAYSIZE_UNSAFE(array) (sizeof(array) / sizeof(array[0]))
-
-#endif // CRASHPAD_UTIL_MISC_ARRAYSIZE_UNSAFE_H_
diff --git a/util/misc/capture_context_test_util_win.cc b/util/misc/capture_context_test_util_win.cc
index 092449e..d8abd37 100644
--- a/util/misc/capture_context_test_util_win.cc
+++ b/util/misc/capture_context_test_util_win.cc
@@ -15,8 +15,8 @@
#include "util/misc/capture_context_test_util.h"
#include "util/win/context_wrappers.h"
-#include "base/macros.h"
#include "gtest/gtest.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -59,7 +59,7 @@
#if defined(ARCH_CPU_X86)
// fxsave doesn’t write these bytes.
- for (size_t i = 464; i < arraysize(context.ExtendedRegisters); ++i) {
+ for (size_t i = 464; i < ArraySize(context.ExtendedRegisters); ++i) {
SCOPED_TRACE(i);
EXPECT_EQ(context.ExtendedRegisters[i], 0);
}
@@ -69,7 +69,7 @@
EXPECT_EQ(context.FltSave.MxCsr, context.MxCsr);
// fxsave doesn’t write these bytes.
- for (size_t i = 0; i < arraysize(context.FltSave.Reserved4); ++i) {
+ for (size_t i = 0; i < ArraySize(context.FltSave.Reserved4); ++i) {
SCOPED_TRACE(i);
EXPECT_EQ(context.FltSave.Reserved4[i], 0);
}
@@ -81,7 +81,7 @@
EXPECT_EQ(context.P4Home, 0u);
EXPECT_EQ(context.P5Home, 0u);
EXPECT_EQ(context.P6Home, 0u);
- for (size_t i = 0; i < arraysize(context.VectorRegister); ++i) {
+ for (size_t i = 0; i < ArraySize(context.VectorRegister); ++i) {
SCOPED_TRACE(i);
EXPECT_EQ(context.VectorRegister[i].Low, 0u);
EXPECT_EQ(context.VectorRegister[i].High, 0u);
diff --git a/util/misc/clock_test.cc b/util/misc/clock_test.cc
index 95330eb..ca4bf00 100644
--- a/util/misc/clock_test.cc
+++ b/util/misc/clock_test.cc
@@ -20,9 +20,9 @@
#include "base/format_macros.h"
#include "base/logging.h"
-#include "base/macros.h"
#include "base/strings/stringprintf.h"
#include "gtest/gtest.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -83,7 +83,7 @@
static_cast<uint64_t>(5E7), // 50 milliseconds
};
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
const uint64_t nanoseconds = kTestData[index];
SCOPED_TRACE(base::StringPrintf(
"index %zu, nanoseconds %" PRIu64, index, nanoseconds));
diff --git a/util/misc/paths_win.cc b/util/misc/paths_win.cc
index 4c402fe..aa5c786 100644
--- a/util/misc/paths_win.cc
+++ b/util/misc/paths_win.cc
@@ -17,18 +17,19 @@
#include <windows.h>
#include "base/logging.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
// static
bool Paths::Executable(base::FilePath* path) {
wchar_t executable_path[_MAX_PATH];
- unsigned int len =
- GetModuleFileName(nullptr, executable_path, arraysize(executable_path));
+ unsigned int len = GetModuleFileName(
+ nullptr, executable_path, static_cast<DWORD>(ArraySize(executable_path)));
if (len == 0) {
PLOG(ERROR) << "GetModuleFileName";
return false;
- } else if (len >= arraysize(executable_path)) {
+ } else if (len >= ArraySize(executable_path)) {
LOG(ERROR) << "GetModuleFileName";
return false;
}
diff --git a/util/misc/random_string_test.cc b/util/misc/random_string_test.cc
index b0866c0..5d9fad6 100644
--- a/util/misc/random_string_test.cc
+++ b/util/misc/random_string_test.cc
@@ -18,8 +18,8 @@
#include <set>
-#include "base/macros.h"
#include "gtest/gtest.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -33,7 +33,7 @@
const std::string allowed_characters("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
size_t character_counts[26] = {};
- ASSERT_EQ(allowed_characters.size(), arraysize(character_counts));
+ ASSERT_EQ(allowed_characters.size(), ArraySize(character_counts));
std::set<std::string> strings;
@@ -61,7 +61,7 @@
// Make sure every character appears at least once. It is possible, but
// extremely unlikely, for a character to not appear at all.
for (size_t character_index = 0;
- character_index < arraysize(character_counts);
+ character_index < ArraySize(character_counts);
++character_index) {
EXPECT_GT(character_counts[character_index], 0u)
<< allowed_characters[character_index];
diff --git a/util/misc/uuid_test.cc b/util/misc/uuid_test.cc
index c05c5c1..b851919 100644
--- a/util/misc/uuid_test.cc
+++ b/util/misc/uuid_test.cc
@@ -20,10 +20,10 @@
#include <string>
#include "base/format_macros.h"
-#include "base/macros.h"
#include "base/scoped_generic.h"
#include "base/strings/stringprintf.h"
#include "gtest/gtest.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -95,12 +95,12 @@
++uuid.data_3;
EXPECT_NE(uuid, uuid_2);
--uuid.data_3;
- for (size_t index = 0; index < arraysize(uuid.data_4); ++index) {
+ for (size_t index = 0; index < ArraySize(uuid.data_4); ++index) {
++uuid.data_4[index];
EXPECT_NE(uuid, uuid_2);
--uuid.data_4[index];
}
- for (size_t index = 0; index < arraysize(uuid.data_5); ++index) {
+ for (size_t index = 0; index < ArraySize(uuid.data_5); ++index) {
++uuid.data_5[index];
EXPECT_NE(uuid, uuid_2);
--uuid.data_5[index];
@@ -190,7 +190,7 @@
uuid_zero.InitializeToZero();
const std::string empty_uuid = uuid_zero.ToString();
- for (size_t index = 0; index < arraysize(kCases); ++index) {
+ for (size_t index = 0; index < ArraySize(kCases); ++index) {
const TestCase& test_case = kCases[index];
SCOPED_TRACE(base::StringPrintf(
"index %" PRIuS ": %s", index, test_case.uuid_string));
@@ -226,7 +226,7 @@
};
// clang-format on
EXPECT_TRUE(uuid.InitializeFromString(
- base::StringPiece16(kChar16UUID, arraysize(kChar16UUID))));
+ base::StringPiece16(kChar16UUID, ArraySize(kChar16UUID))));
EXPECT_EQ(uuid.ToString(), "f32e5bdc-2681-4c73-a4e6-333ffd33b333");
#if defined(OS_WIN)
diff --git a/util/net/http_transport_socket.cc b/util/net/http_transport_socket.cc
index 75ed38f..b390238 100644
--- a/util/net/http_transport_socket.cc
+++ b/util/net/http_transport_socket.cc
@@ -27,6 +27,7 @@
#include "base/strings/string_number_conversions.h"
#include "base/strings/stringprintf.h"
#include "util/file/file_io.h"
+#include "util/misc/arraysize.h"
#include "util/net/http_body.h"
#include "util/net/url.h"
#include "util/stdlib/string_number_conversion.h"
@@ -365,7 +366,7 @@
FileOperationResult data_bytes;
do {
- constexpr size_t kCRLFSize = arraysize(kCRLFTerminator) - 1;
+ constexpr size_t kCRLFSize = ArraySize(kCRLFTerminator) - 1;
struct __attribute__((packed)) {
char size[8];
char crlf[2];
diff --git a/util/net/http_transport_win.cc b/util/net/http_transport_win.cc
index f86e459..06d0b7b 100644
--- a/util/net/http_transport_win.cc
+++ b/util/net/http_transport_win.cc
@@ -31,8 +31,9 @@
#include "build/build_config.h"
#include "package.h"
#include "util/file/file_io.h"
-#include "util/numeric/safe_assignment.h"
+#include "util/misc/arraysize.h"
#include "util/net/http_body.h"
+#include "util/numeric/safe_assignment.h"
#include "util/win/module_version.h"
namespace crashpad {
@@ -95,7 +96,7 @@
error_code,
0,
msgbuf,
- arraysize(msgbuf),
+ static_cast<DWORD>(ArraySize(msgbuf)),
NULL);
if (!len) {
return base::StringPrintf("%s: error 0x%lx while retrieving error 0x%lx",
diff --git a/util/numeric/checked_address_range_test.cc b/util/numeric/checked_address_range_test.cc
index e6bd9ec..f5dc8ad 100644
--- a/util/numeric/checked_address_range_test.cc
+++ b/util/numeric/checked_address_range_test.cc
@@ -19,10 +19,10 @@
#include <limits>
#include "base/format_macros.h"
-#include "base/macros.h"
#include "base/strings/stringprintf.h"
#include "build/build_config.h"
#include "gtest/gtest.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -119,7 +119,7 @@
{0xffffffffffffffff, 1, kInvalid},
};
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
const auto& testcase = kTestData[index];
SCOPED_TRACE(base::StringPrintf("index %" PRIuS
", base 0x%" PRIx64 ", size 0x%" PRIx64,
@@ -170,7 +170,7 @@
CheckedAddressRange parent_range_32(false, 0x2000, 0x1000);
ASSERT_TRUE(parent_range_32.IsValid());
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
const auto& testcase = kTestData[index];
SCOPED_TRACE(base::StringPrintf(
"index %" PRIuS ", value 0x%" PRIx64, index, testcase.value));
@@ -227,7 +227,7 @@
CheckedAddressRange parent_range_32(false, 0x2000, 0x1000);
ASSERT_TRUE(parent_range_32.IsValid());
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
const auto& testcase = kTestData[index];
SCOPED_TRACE(base::StringPrintf("index %" PRIuS
", base 0x%" PRIx64 ", size 0x%" PRIx64,
diff --git a/util/numeric/checked_range_test.cc b/util/numeric/checked_range_test.cc
index 04f6bb1..2977b42 100644
--- a/util/numeric/checked_range_test.cc
+++ b/util/numeric/checked_range_test.cc
@@ -20,9 +20,9 @@
#include <limits>
#include "base/format_macros.h"
-#include "base/macros.h"
#include "base/strings/stringprintf.h"
#include "gtest/gtest.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -78,7 +78,7 @@
{0xffffffff, 0xffffffff, false},
};
- for (size_t index = 0; index < arraysize(kUnsignedTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kUnsignedTestData); ++index) {
const auto& testcase = kUnsignedTestData[index];
SCOPED_TRACE(base::StringPrintf("unsigned index %" PRIuS
", base 0x%x, size 0x%x",
@@ -140,7 +140,7 @@
{-1, 0xffffffff, false},
};
- for (size_t index = 0; index < arraysize(kSignedTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kSignedTestData); ++index) {
const auto& testcase = kSignedTestData[index];
SCOPED_TRACE(base::StringPrintf("signed index %" PRIuS
", base 0x%x, size 0x%x",
@@ -186,7 +186,7 @@
CheckedRange<uint32_t> parent_range(0x2000, 0x1000);
ASSERT_TRUE(parent_range.IsValid());
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
const auto& testcase = kTestData[index];
SCOPED_TRACE(base::StringPrintf(
"index %" PRIuS ", value 0x%x", index, testcase.value));
@@ -234,7 +234,7 @@
CheckedRange<uint32_t> parent_range(0x2000, 0x1000);
ASSERT_TRUE(parent_range.IsValid());
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
const auto& testcase = kTestData[index];
SCOPED_TRACE(base::StringPrintf("index %" PRIuS ", base 0x%x, size 0x%x",
index,
@@ -287,7 +287,7 @@
CheckedRange<uint32_t> first_range(0x2000, 0x1000);
ASSERT_TRUE(first_range.IsValid());
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
const auto& testcase = kTestData[index];
SCOPED_TRACE(base::StringPrintf("index %" PRIuS ", base 0x%x, size 0x%x",
index,
diff --git a/util/posix/close_multiple.cc b/util/posix/close_multiple.cc
index 02c8a76..22f89f5 100644
--- a/util/posix/close_multiple.cc
+++ b/util/posix/close_multiple.cc
@@ -28,6 +28,7 @@
#include "base/strings/string_number_conversions.h"
#include "build/build_config.h"
#include "util/file/directory_reader.h"
+#include "util/misc/arraysize.h"
#include "util/misc/implicit_cast.h"
#if defined(OS_MACOSX)
@@ -152,7 +153,7 @@
int maxfilesperproc;
size_t maxfilesperproc_size = sizeof(maxfilesperproc);
if (sysctl(oid,
- arraysize(oid),
+ ArraySize(oid),
&maxfilesperproc,
&maxfilesperproc_size,
nullptr,
diff --git a/util/posix/close_stdio.cc b/util/posix/close_stdio.cc
index cc9cdac..02bd4a9 100644
--- a/util/posix/close_stdio.cc
+++ b/util/posix/close_stdio.cc
@@ -20,6 +20,7 @@
#include "base/files/scoped_file.h"
#include "base/logging.h"
+#include "base/macros.h"
#include "base/posix/eintr_wrapper.h"
namespace crashpad {
diff --git a/util/posix/process_info_mac.cc b/util/posix/process_info_mac.cc
index fe9fb65..8b9a6ec 100644
--- a/util/posix/process_info_mac.cc
+++ b/util/posix/process_info_mac.cc
@@ -18,6 +18,7 @@
#include "base/logging.h"
#include "base/mac/mach_logging.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
@@ -32,7 +33,7 @@
int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid};
size_t len = sizeof(kern_proc_info_);
- if (sysctl(mib, arraysize(mib), &kern_proc_info_, &len, nullptr, 0) != 0) {
+ if (sysctl(mib, ArraySize(mib), &kern_proc_info_, &len, nullptr, 0) != 0) {
PLOG(ERROR) << "sysctl for pid " << pid;
return false;
}
@@ -111,7 +112,7 @@
const short ngroups = kern_proc_info_.kp_eproc.e_ucred.cr_ngroups;
DCHECK_GE(ngroups, 0);
DCHECK_LE(static_cast<size_t>(ngroups),
- arraysize(kern_proc_info_.kp_eproc.e_ucred.cr_groups));
+ ArraySize(kern_proc_info_.kp_eproc.e_ucred.cr_groups));
const gid_t* groups = kern_proc_info_.kp_eproc.e_ucred.cr_groups;
return std::set<gid_t>(&groups[0], &groups[ngroups]);
@@ -168,7 +169,7 @@
do {
int mib[] = {CTL_KERN, KERN_PROCARGS2, pid};
int rv =
- sysctl(mib, arraysize(mib), nullptr, &args_size_estimate, nullptr, 0);
+ sysctl(mib, ArraySize(mib), nullptr, &args_size_estimate, nullptr, 0);
if (rv != 0) {
PLOG(ERROR) << "sysctl (size) for pid " << pid;
return false;
@@ -176,7 +177,7 @@
args_size = args_size_estimate + 1;
args.resize(args_size);
- rv = sysctl(mib, arraysize(mib), &args[0], &args_size, nullptr, 0);
+ rv = sysctl(mib, ArraySize(mib), &args[0], &args_size, nullptr, 0);
if (rv != 0) {
PLOG(ERROR) << "sysctl (data) for pid " << pid;
return false;
diff --git a/util/posix/scoped_mmap_test.cc b/util/posix/scoped_mmap_test.cc
index 7312b84..0a6a1fa 100644
--- a/util/posix/scoped_mmap_test.cc
+++ b/util/posix/scoped_mmap_test.cc
@@ -23,6 +23,7 @@
#include "base/strings/stringprintf.h"
#include "gtest/gtest.h"
#include "test/gtest_death.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -150,7 +151,7 @@
EXPECT_EQ(mapping.len(), 3 * kPageSize);
TestCookie cookies[3];
- for (size_t index = 0; index < arraysize(cookies); ++index) {
+ for (size_t index = 0; index < ArraySize(cookies); ++index) {
cookies[index].SetUp(reinterpret_cast<uint64_t*>(
mapping.addr_as<uintptr_t>() + index * kPageSize));
}
@@ -185,7 +186,7 @@
EXPECT_EQ(mapping.len(), kPageSize);
TestCookie cookies[3];
- for (size_t index = 0; index < arraysize(cookies); ++index) {
+ for (size_t index = 0; index < ArraySize(cookies); ++index) {
cookies[index].SetUp(reinterpret_cast<uint64_t*>(
reinterpret_cast<uintptr_t>(pages) + index * kPageSize));
}
@@ -196,7 +197,7 @@
EXPECT_EQ(mapping.addr(), pages);
EXPECT_EQ(mapping.len(), 3 * kPageSize);
- for (size_t index = 0; index < arraysize(cookies); ++index) {
+ for (size_t index = 0; index < ArraySize(cookies); ++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
EXPECT_EQ(cookies[index].Observed(), cookies[index].Expected());
}
@@ -217,7 +218,7 @@
EXPECT_EQ(mapping.len(), kPageSize);
TestCookie cookies[3];
- for (size_t index = 0; index < arraysize(cookies); ++index) {
+ for (size_t index = 0; index < ArraySize(cookies); ++index) {
cookies[index].SetUp(reinterpret_cast<uint64_t*>(
reinterpret_cast<uintptr_t>(pages) + index * kPageSize));
}
@@ -248,7 +249,7 @@
EXPECT_EQ(mapping.len(), 2 * kPageSize);
TestCookie cookies[3];
- for (size_t index = 0; index < arraysize(cookies); ++index) {
+ for (size_t index = 0; index < ArraySize(cookies); ++index) {
cookies[index].SetUp(reinterpret_cast<uint64_t*>(
reinterpret_cast<uintptr_t>(pages) + index * kPageSize));
}
diff --git a/util/posix/signals.cc b/util/posix/signals.cc
index 63764ab..69cdfca 100644
--- a/util/posix/signals.cc
+++ b/util/posix/signals.cc
@@ -19,6 +19,7 @@
#include <vector>
#include "base/logging.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
@@ -118,7 +119,7 @@
struct sigaction* Signals::OldActions::ActionForSignal(int sig) {
DCHECK_GT(sig, 0);
const size_t slot = sig - 1;
- DCHECK_LT(slot, arraysize(actions_));
+ DCHECK_LT(slot, ArraySize(actions_));
return &actions_[slot];
}
@@ -152,7 +153,7 @@
int flags,
OldActions* old_actions) {
return InstallHandlers(
- std::vector<int>(kCrashSignals, kCrashSignals + arraysize(kCrashSignals)),
+ std::vector<int>(kCrashSignals, kCrashSignals + ArraySize(kCrashSignals)),
handler,
flags,
old_actions);
@@ -164,7 +165,7 @@
OldActions* old_actions) {
return InstallHandlers(
std::vector<int>(kTerminateSignals,
- kTerminateSignals + arraysize(kTerminateSignals)),
+ kTerminateSignals + ArraySize(kTerminateSignals)),
handler,
flags,
old_actions);
@@ -279,12 +280,12 @@
// static
bool Signals::IsCrashSignal(int sig) {
- return IsSignalInSet(sig, kCrashSignals, arraysize(kCrashSignals));
+ return IsSignalInSet(sig, kCrashSignals, ArraySize(kCrashSignals));
}
// static
bool Signals::IsTerminateSignal(int sig) {
- return IsSignalInSet(sig, kTerminateSignals, arraysize(kTerminateSignals));
+ return IsSignalInSet(sig, kTerminateSignals, ArraySize(kTerminateSignals));
}
} // namespace crashpad
diff --git a/util/posix/signals_test.cc b/util/posix/signals_test.cc
index 75ff558..b0c8407 100644
--- a/util/posix/signals_test.cc
+++ b/util/posix/signals_test.cc
@@ -32,6 +32,7 @@
#include "test/errors.h"
#include "test/multiprocess.h"
#include "test/scoped_temp_dir.h"
+#include "util/misc/arraysize.h"
#include "util/posix/scoped_mmap.h"
namespace crashpad {
@@ -340,7 +341,7 @@
{SIGHUP, SEGV_MAPERR, false},
{SIGINT, SI_USER, false},
};
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
const auto test_data = kTestData[index];
SCOPED_TRACE(base::StringPrintf(
"index %zu, sig %d, code %d", index, test_data.sig, test_data.code));
diff --git a/util/posix/symbolic_constants_posix.cc b/util/posix/symbolic_constants_posix.cc
index 8008ffb..f1fa87f 100644
--- a/util/posix/symbolic_constants_posix.cc
+++ b/util/posix/symbolic_constants_posix.cc
@@ -18,9 +18,9 @@
#include <string.h>
#include <sys/types.h>
-#include "base/macros.h"
#include "base/strings/stringprintf.h"
#include "build/build_config.h"
+#include "util/misc/arraysize.h"
#include "util/misc/implicit_cast.h"
#include "util/stdlib/string_number_conversion.h"
@@ -137,9 +137,9 @@
};
#if defined(OS_LINUX) || defined(OS_ANDROID)
// NSIG is 64 to account for real-time signals.
-static_assert(arraysize(kSignalNames) == 32, "kSignalNames length");
+static_assert(ArraySize(kSignalNames) == 32, "kSignalNames length");
#else
-static_assert(arraysize(kSignalNames) == NSIG, "kSignalNames length");
+static_assert(ArraySize(kSignalNames) == NSIG, "kSignalNames length");
#endif
constexpr char kSigPrefix[] = "SIG";
@@ -151,7 +151,7 @@
std::string SignalToString(int signal,
SymbolicConstantToStringOptions options) {
const char* signal_name =
- implicit_cast<size_t>(signal) < arraysize(kSignalNames)
+ implicit_cast<size_t>(signal) < ArraySize(kSignalNames)
? kSignalNames[signal]
: nullptr;
if (!signal_name) {
@@ -176,8 +176,7 @@
string.substr(0, strlen(kSigPrefix)).compare(kSigPrefix) == 0;
base::StringPiece short_string =
can_match_full ? string.substr(strlen(kSigPrefix)) : string;
- for (int index = 0;
- index < implicit_cast<int>(arraysize(kSignalNames));
+ for (int index = 0; index < implicit_cast<int>(ArraySize(kSignalNames));
++index) {
const char* signal_name = kSignalNames[index];
if (!signal_name) {
diff --git a/util/posix/symbolic_constants_posix_test.cc b/util/posix/symbolic_constants_posix_test.cc
index 32c1d43..1a6e0b9 100644
--- a/util/posix/symbolic_constants_posix_test.cc
+++ b/util/posix/symbolic_constants_posix_test.cc
@@ -17,13 +17,14 @@
#include <signal.h>
#include <sys/types.h>
-#include "base/macros.h"
#include "base/strings/string_piece.h"
#include "base/strings/stringprintf.h"
#include "build/build_config.h"
#include "gtest/gtest.h"
+#include "util/misc/arraysize.h"
-#define NUL_TEST_DATA(string) { string, arraysize(string) - 1 }
+#define NUL_TEST_DATA(string) \
+ { string, ArraySize(string) - 1 }
namespace crashpad {
namespace test {
@@ -115,7 +116,7 @@
}
TEST(SymbolicConstantsPOSIX, SignalToString) {
- for (size_t index = 0; index < arraysize(kSignalTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kSignalTestData); ++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
TestSignalToString(kSignalTestData[index].signal,
kSignalTestData[index].full_name,
@@ -170,12 +171,11 @@
kAllowFullName | kAllowShortName | kAllowNumber,
};
- for (size_t option_index = 0;
- option_index < arraysize(kOptions);
+ for (size_t option_index = 0; option_index < ArraySize(kOptions);
++option_index) {
SCOPED_TRACE(base::StringPrintf("option_index %zu", option_index));
StringToSymbolicConstantOptions options = kOptions[option_index];
- for (size_t index = 0; index < arraysize(kSignalTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kSignalTestData); ++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
int signal = kSignalTestData[index].signal;
{
@@ -213,7 +213,7 @@
"",
};
- for (size_t index = 0; index < arraysize(kNegativeTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kNegativeTestData); ++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
TestStringToSignal(kNegativeTestData[index], options, false, 0);
}
@@ -234,7 +234,7 @@
NUL_TEST_DATA("1\0002"),
};
- for (size_t index = 0; index < arraysize(kNULTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kNULTestData); ++index) {
SCOPED_TRACE(base::StringPrintf("index %zu", index));
base::StringPiece string(kNULTestData[index].string,
kNULTestData[index].length);
diff --git a/util/process/process_memory_range_test.cc b/util/process/process_memory_range_test.cc
index fa2a893..9431d44 100644
--- a/util/process/process_memory_range_test.cc
+++ b/util/process/process_memory_range_test.cc
@@ -19,9 +19,10 @@
#include "base/logging.h"
#include "build/build_config.h"
#include "gtest/gtest.h"
+#include "test/process_type.h"
+#include "util/misc/arraysize.h"
#include "util/misc/from_pointer_cast.h"
#include "util/process/process_memory_native.h"
-#include "test/process_type.h"
namespace crashpad {
namespace test {
@@ -58,28 +59,28 @@
auto string1_addr = FromPointerCast<VMAddress>(kTestObject.string1);
auto string2_addr = FromPointerCast<VMAddress>(kTestObject.string2);
ASSERT_TRUE(range.ReadCStringSizeLimited(
- string1_addr, arraysize(kTestObject.string1), &string));
+ string1_addr, ArraySize(kTestObject.string1), &string));
EXPECT_STREQ(string.c_str(), kTestObject.string1);
ASSERT_TRUE(range.ReadCStringSizeLimited(
- string2_addr, arraysize(kTestObject.string2), &string));
+ string2_addr, ArraySize(kTestObject.string2), &string));
EXPECT_STREQ(string.c_str(), kTestObject.string2);
// Limit the range to remove access to string2.
ProcessMemoryRange range2;
ASSERT_TRUE(range2.Initialize(range));
ASSERT_TRUE(
- range2.RestrictRange(string1_addr, arraysize(kTestObject.string1)));
+ range2.RestrictRange(string1_addr, ArraySize(kTestObject.string1)));
EXPECT_TRUE(range2.ReadCStringSizeLimited(
- string1_addr, arraysize(kTestObject.string1), &string));
+ string1_addr, ArraySize(kTestObject.string1), &string));
EXPECT_FALSE(range2.ReadCStringSizeLimited(
- string2_addr, arraysize(kTestObject.string2), &string));
+ string2_addr, ArraySize(kTestObject.string2), &string));
EXPECT_FALSE(range2.Read(object_addr, sizeof(object), &object));
// String reads fail if the NUL terminator is outside the range.
ASSERT_TRUE(range2.RestrictRange(string1_addr, strlen(kTestObject.string1)));
EXPECT_FALSE(range2.ReadCStringSizeLimited(
- string1_addr, arraysize(kTestObject.string1), &string));
+ string1_addr, ArraySize(kTestObject.string1), &string));
// New range outside the old range.
EXPECT_FALSE(range2.RestrictRange(string1_addr - 1, 1));
diff --git a/util/stdlib/string_number_conversion_test.cc b/util/stdlib/string_number_conversion_test.cc
index d855c8d..ee19429 100644
--- a/util/stdlib/string_number_conversion_test.cc
+++ b/util/stdlib/string_number_conversion_test.cc
@@ -18,8 +18,8 @@
#include <limits>
-#include "base/macros.h"
#include "gtest/gtest.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -94,7 +94,7 @@
{"18446744073709551616", false, 0},
};
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
int value;
bool valid = StringToNumber(kTestData[index].string, &value);
if (kTestData[index].valid) {
@@ -114,7 +114,7 @@
// is split to avoid MSVC warning:
// "decimal digit terminates octal escape sequence".
static constexpr char input[] = "6\000" "6";
- std::string input_string(input, arraysize(input) - 1);
+ std::string input_string(input, ArraySize(input) - 1);
int output;
EXPECT_FALSE(StringToNumber(input_string, &output));
}
@@ -188,7 +188,7 @@
{"18446744073709551616", false, 0},
};
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
unsigned int value;
bool valid = StringToNumber(kTestData[index].string, &value);
if (kTestData[index].valid) {
@@ -208,7 +208,7 @@
// is split to avoid MSVC warning:
// "decimal digit terminates octal escape sequence".
static constexpr char input[] = "6\000" "6";
- std::string input_string(input, arraysize(input) - 1);
+ std::string input_string(input, ArraySize(input) - 1);
unsigned int output;
EXPECT_FALSE(StringToNumber(input_string, &output));
}
@@ -245,7 +245,7 @@
{"0x7Fffffffffffffff", true, std::numeric_limits<int64_t>::max()},
};
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
int64_t value;
bool valid = StringToNumber(kTestData[index].string, &value);
if (kTestData[index].valid) {
@@ -295,7 +295,7 @@
{"0xFfffffffffffffff", true, std::numeric_limits<uint64_t>::max()},
};
- for (size_t index = 0; index < arraysize(kTestData); ++index) {
+ for (size_t index = 0; index < ArraySize(kTestData); ++index) {
uint64_t value;
bool valid = StringToNumber(kTestData[index].string, &value);
if (kTestData[index].valid) {
diff --git a/util/stdlib/strlcpy_test.cc b/util/stdlib/strlcpy_test.cc
index 5d20e19..172a09a 100644
--- a/util/stdlib/strlcpy_test.cc
+++ b/util/stdlib/strlcpy_test.cc
@@ -20,10 +20,10 @@
#include <algorithm>
#include "base/format_macros.h"
-#include "base/macros.h"
#include "base/strings/string16.h"
#include "base/strings/stringprintf.h"
#include "gtest/gtest.h"
+#include "util/misc/arraysize.h"
namespace crashpad {
namespace test {
@@ -64,7 +64,7 @@
static constexpr base::char16 test_characters[] =
{0x4d, 0xe9, 0x100, 0x151, 0x1e18};
- for (size_t index = 0; index < arraysize(test_characters); ++index) {
+ for (size_t index = 0; index < ArraySize(test_characters); ++index) {
base::char16 test_character = test_characters[index];
SCOPED_TRACE(base::StringPrintf(
"character index %" PRIuS ", character 0x%x", index, test_character));
@@ -78,13 +78,13 @@
EXPECT_EQ(c16lcpy(destination.data,
test_string.c_str(),
- arraysize(destination.data)),
+ ArraySize(destination.data)),
length);
// Make sure that the destination buffer is NUL-terminated, and that as
// much of the test string was copied as could fit.
size_t expected_destination_length =
- std::min(length, arraysize(destination.data) - 1);
+ std::min(length, ArraySize(destination.data) - 1);
EXPECT_EQ(destination.data[expected_destination_length], '\0');
EXPECT_EQ(C16Len(destination.data), expected_destination_length);
@@ -97,15 +97,15 @@
// of the buffer passed to c16lcpy.
EXPECT_TRUE(C16Memcmp(expected_untouched.lead_guard,
destination.lead_guard,
- arraysize(destination.lead_guard)) == 0);
+ ArraySize(destination.lead_guard)) == 0);
size_t expected_untouched_length =
- arraysize(destination.data) - expected_destination_length - 1;
+ ArraySize(destination.data) - expected_destination_length - 1;
EXPECT_TRUE(C16Memcmp(expected_untouched.data,
&destination.data[expected_destination_length + 1],
expected_untouched_length) == 0);
EXPECT_TRUE(C16Memcmp(expected_untouched.trail_guard,
destination.trail_guard,
- arraysize(destination.trail_guard)) == 0);
+ ArraySize(destination.trail_guard)) == 0);
}
}
}
diff --git a/util/stdlib/thread_safe_vector_test.cc b/util/stdlib/thread_safe_vector_test.cc
index 805360f..183c636 100644
--- a/util/stdlib/thread_safe_vector_test.cc
+++ b/util/stdlib/thread_safe_vector_test.cc
@@ -15,6 +15,7 @@
#include "util/stdlib/thread_safe_vector.h"
#include "gtest/gtest.h"
+#include "util/misc/arraysize.h"
#include "util/thread/thread.h"
namespace crashpad {
@@ -53,12 +54,12 @@
EXPECT_TRUE(vector.empty());
ThreadSafeVectorTestThread threads[100];
- for (size_t index = 0; index < arraysize(threads); ++index) {
+ for (size_t index = 0; index < ArraySize(threads); ++index) {
threads[index].SetTestParameters(
&thread_safe_vector, static_cast<int>(index * kElementsPerThread));
}
- for (size_t index = 0; index < arraysize(threads); ++index) {
+ for (size_t index = 0; index < ArraySize(threads); ++index) {
threads[index].Start();
if (index % 10 == 0) {
@@ -75,8 +76,8 @@
std::vector<int> drained = thread_safe_vector.Drain();
vector.insert(vector.end(), drained.begin(), drained.end());
- bool found[arraysize(threads) * kElementsPerThread] = {};
- EXPECT_EQ(vector.size(), arraysize(found));
+ bool found[ArraySize(threads) * kElementsPerThread] = {};
+ EXPECT_EQ(vector.size(), ArraySize(found));
for (int element : vector) {
EXPECT_FALSE(found[element]) << element;
found[element] = true;
diff --git a/util/synchronization/semaphore_test.cc b/util/synchronization/semaphore_test.cc
index 10f7546..fedead1 100644
--- a/util/synchronization/semaphore_test.cc
+++ b/util/synchronization/semaphore_test.cc
@@ -16,8 +16,8 @@
#include <sys/types.h>
-#include "base/macros.h"
#include "gtest/gtest.h"
+#include "util/misc/arraysize.h"
#if defined(OS_POSIX)
#include <pthread.h>
@@ -126,7 +126,7 @@
Semaphore semaphore(5);
ThreadMainInfo info[10];
size_t iterations = 0;
- for (size_t index = 0; index < arraysize(info); ++index) {
+ for (size_t index = 0; index < ArraySize(info); ++index) {
info[index].semaphore = &semaphore;
info[index].iterations = index;
iterations += info[index].iterations;
@@ -138,7 +138,7 @@
semaphore.Signal();
}
- for (size_t index = 0; index < arraysize(info); ++index) {
+ for (size_t index = 0; index < ArraySize(info); ++index) {
JoinThread(&info[index]);
}
}
diff --git a/util/thread/thread_log_messages_test.cc b/util/thread/thread_log_messages_test.cc
index 00b612c..f186ed2 100644
--- a/util/thread/thread_log_messages_test.cc
+++ b/util/thread/thread_log_messages_test.cc
@@ -20,6 +20,7 @@
#include "base/logging.h"
#include "base/strings/stringprintf.h"
#include "gtest/gtest.h"
+#include "util/misc/arraysize.h"
#include "util/thread/thread.h"
namespace crashpad {
@@ -93,8 +94,8 @@
const std::vector<std::string>& log_messages =
thread_log_messages.log_messages();
- EXPECT_EQ(log_messages.size(), arraysize(kMessages));
- for (size_t index = 0; index < arraysize(kMessages); ++index) {
+ EXPECT_EQ(log_messages.size(), ArraySize(kMessages));
+ for (size_t index = 0; index < ArraySize(kMessages); ++index) {
EXPECT_EQ(MessageString(log_messages[index]), kMessages[index])
<< "index " << index;
}
@@ -173,7 +174,7 @@
LoggingTestThread threads[20];
int start = 0;
- for (size_t index = 0; index < arraysize(threads); ++index) {
+ for (size_t index = 0; index < ArraySize(threads); ++index) {
threads[index].Initialize(
index, static_cast<int>(start), static_cast<int>(index));
start += static_cast<int>(index);
diff --git a/util/thread/thread_test.cc b/util/thread/thread_test.cc
index d92544b..47a711c 100644
--- a/util/thread/thread_test.cc
+++ b/util/thread/thread_test.cc
@@ -14,7 +14,6 @@
#include "util/thread/thread.h"
-#include "base/macros.h"
#include "gtest/gtest.h"
#include "util/synchronization/semaphore.h"
diff --git a/util/util.gyp b/util/util.gyp
index dc82287..32be8ba 100644
--- a/util/util.gyp
+++ b/util/util.gyp
@@ -126,7 +126,7 @@
'mach/task_for_pid.h',
'misc/address_sanitizer.h',
'misc/address_types.h',
- 'misc/arraysize_unsafe.h',
+ 'misc/arraysize.h',
'misc/as_underlying_type.h',
'misc/capture_context.h',
'misc/capture_context_linux.S',
diff --git a/util/util_test.gyp b/util/util_test.gyp
index b3c8d41..9edd3dc 100644
--- a/util/util_test.gyp
+++ b/util/util_test.gyp
@@ -65,7 +65,7 @@
'mach/notify_server_test.cc',
'mach/scoped_task_suspend_test.cc',
'mach/symbolic_constants_mach_test.cc',
- 'misc/arraysize_unsafe_test.cc',
+ 'misc/arraysize_test.cc',
'misc/capture_context_test.cc',
'misc/capture_context_test_util.h',
'misc/capture_context_test_util_linux.cc',
diff --git a/util/win/command_line_test.cc b/util/win/command_line_test.cc
index 025ef8a..e5ceef8 100644
--- a/util/win/command_line_test.cc
+++ b/util/win/command_line_test.cc
@@ -19,10 +19,10 @@
#include <sys/types.h>
#include "base/logging.h"
-#include "base/macros.h"
#include "base/scoped_generic.h"
#include "gtest/gtest.h"
#include "test/errors.h"
+#include "util/misc/arraysize.h"
#include "util/win/scoped_local_alloc.h"
namespace crashpad {
@@ -65,7 +65,7 @@
L"argument 1",
L"argument 2",
};
- AppendCommandLineArgumentTest(arraysize(kArguments), kArguments);
+ AppendCommandLineArgumentTest(ArraySize(kArguments), kArguments);
}
{
@@ -77,7 +77,7 @@
L"argument 2",
L"\\some\\path with\\spaces",
};
- AppendCommandLineArgumentTest(arraysize(kArguments), kArguments);
+ AppendCommandLineArgumentTest(ArraySize(kArguments), kArguments);
}
{
@@ -89,7 +89,7 @@
L"she said, \"you had me at hello\"",
L"\\some\\path with\\spaces",
};
- AppendCommandLineArgumentTest(arraysize(kArguments), kArguments);
+ AppendCommandLineArgumentTest(ArraySize(kArguments), kArguments);
}
{
@@ -102,7 +102,7 @@
L"argument3",
L"argument4",
};
- AppendCommandLineArgumentTest(arraysize(kArguments), kArguments);
+ AppendCommandLineArgumentTest(ArraySize(kArguments), kArguments);
}
{
@@ -113,7 +113,7 @@
L"\\some\\directory with\\spaces\\",
L"argument2",
};
- AppendCommandLineArgumentTest(arraysize(kArguments), kArguments);
+ AppendCommandLineArgumentTest(ArraySize(kArguments), kArguments);
}
{
@@ -124,7 +124,7 @@
L"",
L"argument2",
};
- AppendCommandLineArgumentTest(arraysize(kArguments), kArguments);
+ AppendCommandLineArgumentTest(ArraySize(kArguments), kArguments);
}
{
@@ -159,7 +159,7 @@
L"\"\"",
L" \t\n\v\"",
};
- AppendCommandLineArgumentTest(arraysize(kArguments), kArguments);
+ AppendCommandLineArgumentTest(ArraySize(kArguments), kArguments);
}
}
diff --git a/util/win/exception_handler_server.cc b/util/win/exception_handler_server.cc
index 6642665..8ca3d25 100644
--- a/util/win/exception_handler_server.cc
+++ b/util/win/exception_handler_server.cc
@@ -29,6 +29,7 @@
#include "snapshot/crashpad_info_client_options.h"
#include "snapshot/win/process_snapshot_win.h"
#include "util/file/file_writer.h"
+#include "util/misc/arraysize.h"
#include "util/misc/tri_state.h"
#include "util/misc/uuid.h"
#include "util/win/get_function.h"
@@ -307,7 +308,7 @@
void ExceptionHandlerServer::Run(Delegate* delegate) {
uint64_t shutdown_token = base::RandUint64();
ScopedKernelHANDLE thread_handles[kPipeInstances];
- for (size_t i = 0; i < arraysize(thread_handles); ++i) {
+ for (size_t i = 0; i < ArraySize(thread_handles); ++i) {
HANDLE pipe;
if (first_pipe_instance_.is_valid()) {
pipe = first_pipe_instance_.release();
@@ -359,7 +360,7 @@
}
// Signal to the named pipe instances that they should terminate.
- for (size_t i = 0; i < arraysize(thread_handles); ++i) {
+ for (size_t i = 0; i < ArraySize(thread_handles); ++i) {
ClientToServerMessage message;
memset(&message, 0, sizeof(message));
message.type = ClientToServerMessage::kShutdown;
diff --git a/util/win/ntstatus_logging.cc b/util/win/ntstatus_logging.cc
index 442e49f..118bfef 100644
--- a/util/win/ntstatus_logging.cc
+++ b/util/win/ntstatus_logging.cc
@@ -17,6 +17,7 @@
#include <string>
#include "base/strings/stringprintf.h"
+#include "util/misc/arraysize.h"
namespace {
@@ -29,7 +30,7 @@
ntstatus,
0,
msgbuf,
- arraysize(msgbuf),
+ static_cast<DWORD>(ArraySize(msgbuf)),
nullptr);
if (len) {
// Most system messages end in a period and a space. Remove the space if
diff --git a/util/win/registration_protocol_win.cc b/util/win/registration_protocol_win.cc
index 4fb536d..412f8da 100644
--- a/util/win/registration_protocol_win.cc
+++ b/util/win/registration_protocol_win.cc
@@ -18,7 +18,7 @@
#include <windows.h>
#include "base/logging.h"
-#include "base/macros.h"
+#include "util/misc/arraysize.h"
#include "util/win/exception_handler_server.h"
#include "util/win/scoped_handle.h"
@@ -168,7 +168,7 @@
ACL_REVISION, // AclRevision.
0, // Sbz1.
sizeof(kSecDescBlob.sacl), // AclSize.
- arraysize(kSecDescBlob.sacl.ace), // AceCount.
+ static_cast<WORD>(ArraySize(kSecDescBlob.sacl.ace)), // AceCount.
0, // Sbz2.
},
@@ -188,8 +188,9 @@
// sid.
{
SID_REVISION, // Revision.
- // SubAuthorityCount.
- arraysize(kSecDescBlob.sacl.ace[0].sid.SubAuthority),
+ // SubAuthorityCount.
+ static_cast<BYTE>(
+ ArraySize(kSecDescBlob.sacl.ace[0].sid.SubAuthority)),
// IdentifierAuthority.
{SECURITY_MANDATORY_LABEL_AUTHORITY},
{SECURITY_MANDATORY_UNTRUSTED_RID}, // SubAuthority.
diff --git a/util/win/safe_terminate_process_test.cc b/util/win/safe_terminate_process_test.cc
index f9db161..a62fb14 100644
--- a/util/win/safe_terminate_process_test.cc
+++ b/util/win/safe_terminate_process_test.cc
@@ -27,6 +27,7 @@
#include "test/errors.h"
#include "test/test_paths.h"
#include "test/win/child_launcher.h"
+#include "util/misc/arraysize.h"
#include "util/win/scoped_handle.h"
namespace crashpad {
@@ -148,7 +149,7 @@
};
void* target = reinterpret_cast<void*>(TerminateProcess);
- ScopedExecutablePatch executable_patch(target, patch, arraysize(patch));
+ ScopedExecutablePatch executable_patch(target, patch, ArraySize(patch));
// Make sure that SafeTerminateProcess() can be called. Since it’s been
// patched with a no-op stub, GetLastError() shouldn’t be modified.