Added a new SafeSPrintf() function that implements snprintf() in an async-safe-fashion

base/debug/stack_trace_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <limits>
 #include <sstream>
 #include <string>
 
+#include "base/debug/format.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/process/kill.h"
 #include "base/process/process_handle.h"
 #include "base/test/test_timeouts.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/multiprocess_func_list.h"
 
 #if defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_IOS)
 #include "base/test/multiprocess_test.h"
@@ skipping 126 matching lines @@
 // of re-entering malloc.
 TEST_F(StackTraceTest, AsyncSignalUnsafeSignalHandlerHang) {
   ProcessHandle child = this->SpawnChild("MismatchedMallocChildProcess", false);
   ASSERT_NE(kNullProcessHandle, child);
   ASSERT_TRUE(WaitForSingleProcess(child, TestTimeouts::action_timeout()));
 }
 #endif  // !defined(OS_IOS)
 
 namespace {
 
-std::string itoa_r_wrapper(intptr_t i, size_t sz, int base, size_t padding) {
-  char buffer[1024];
+std::string itoa_r(intptr_t i, size_t sz, int base, size_t padding) {

[jln (very slow on Chromium), 2013/08/01 00:03:15]

I wonder if you shouldn't expose itoa_r() and just leave most of this untouched.

+  // The stack tracer uses Format() to convert integer values to ASCII.
+  // It doesn't need all of the features of Format(), but instead restricts
+  // itself to a subset that can be thought of as an itoa_r() function.
+  char buffer[130];
   CHECK_LE(sz, sizeof(buffer));
-
-  char* result = internal::itoa_r(i, buffer, sz, base, padding);
-  EXPECT_TRUE(result);
+  CHECK_LE(sizeof(intptr_t)*8+1, sizeof(buffer));
+  char format[40];
+  EXPECT_TRUE(base == 10 || base == 16);
+  CHECK_LT(Format(format, "%%0%d%c", padding, base == 10 ? 'd' : 'x'),
+           static_cast<ssize_t>(sizeof(format)));
+  CHECK_LT(FormatN(buffer, sz, format, i),
+           static_cast<ssize_t>(sizeof(buffer)));
   return std::string(buffer);
 }
 
 }  // namespace
 
 TEST_F(StackTraceTest, itoa_r) {
-  EXPECT_EQ("0", itoa_r_wrapper(0, 128, 10, 0));
-  EXPECT_EQ("-1", itoa_r_wrapper(-1, 128, 10, 0));
+  EXPECT_EQ("0", itoa_r(0, 128, 10, 0));
+  EXPECT_EQ("-1", itoa_r(-1, 128, 10, 0));
 
   // Test edge cases.
   if (sizeof(intptr_t) == 4) {
-    EXPECT_EQ("ffffffff", itoa_r_wrapper(-1, 128, 16, 0));
+    EXPECT_EQ("ffffffff", itoa_r(-1, 128, 16, 0));
     EXPECT_EQ("-2147483648",
-              itoa_r_wrapper(std::numeric_limits<intptr_t>::min(), 128, 10, 0));
+              itoa_r(std::numeric_limits<intptr_t>::min(), 128, 10, 0));
     EXPECT_EQ("2147483647",
-              itoa_r_wrapper(std::numeric_limits<intptr_t>::max(), 128, 10, 0));
+              itoa_r(std::numeric_limits<intptr_t>::max(), 128, 10, 0));
 
     EXPECT_EQ("80000000",
-              itoa_r_wrapper(std::numeric_limits<intptr_t>::min(), 128, 16, 0));
+              itoa_r(std::numeric_limits<intptr_t>::min(), 128, 16, 0));
     EXPECT_EQ("7fffffff",
-              itoa_r_wrapper(std::numeric_limits<intptr_t>::max(), 128, 16, 0));
+              itoa_r(std::numeric_limits<intptr_t>::max(), 128, 16, 0));
   } else if (sizeof(intptr_t) == 8) {
-    EXPECT_EQ("ffffffffffffffff", itoa_r_wrapper(-1, 128, 16, 0));
+    EXPECT_EQ("ffffffffffffffff", itoa_r(-1, 128, 16, 0));
     EXPECT_EQ("-9223372036854775808",
-              itoa_r_wrapper(std::numeric_limits<intptr_t>::min(), 128, 10, 0));
+              itoa_r(std::numeric_limits<intptr_t>::min(), 128, 10, 0));
     EXPECT_EQ("9223372036854775807",
-              itoa_r_wrapper(std::numeric_limits<intptr_t>::max(), 128, 10, 0));
+              itoa_r(std::numeric_limits<intptr_t>::max(), 128, 10, 0));
 
     EXPECT_EQ("8000000000000000",
-              itoa_r_wrapper(std::numeric_limits<intptr_t>::min(), 128, 16, 0));
+              itoa_r(std::numeric_limits<intptr_t>::min(), 128, 16, 0));
     EXPECT_EQ("7fffffffffffffff",
-              itoa_r_wrapper(std::numeric_limits<intptr_t>::max(), 128, 16, 0));
+              itoa_r(std::numeric_limits<intptr_t>::max(), 128, 16, 0));
   } else {
     ADD_FAILURE() << "Missing test case for your size of intptr_t ("
                   << sizeof(intptr_t) << ")";
   }
 
   // Test hex output.
-  EXPECT_EQ("688", itoa_r_wrapper(0x688, 128, 16, 0));
-  EXPECT_EQ("deadbeef", itoa_r_wrapper(0xdeadbeef, 128, 16, 0));
+  EXPECT_EQ("688", itoa_r(0x688, 128, 16, 0));
+  EXPECT_EQ("deadbeef", itoa_r(0xdeadbeef, 128, 16, 0));
 
   // Check that itoa_r respects passed buffer size limit.
-  char buffer[1024];
-  EXPECT_TRUE(internal::itoa_r(0xdeadbeef, buffer, 10, 16, 0));
-  EXPECT_TRUE(internal::itoa_r(0xdeadbeef, buffer, 9, 16, 0));
-  EXPECT_FALSE(internal::itoa_r(0xdeadbeef, buffer, 8, 16, 0));
-  EXPECT_FALSE(internal::itoa_r(0xdeadbeef, buffer, 7, 16, 0));
-  EXPECT_TRUE(internal::itoa_r(0xbeef, buffer, 5, 16, 4));
-  EXPECT_FALSE(internal::itoa_r(0xbeef, buffer, 5, 16, 5));
-  EXPECT_FALSE(internal::itoa_r(0xbeef, buffer, 5, 16, 6));
+  EXPECT_EQ("deadbeef", itoa_r(0xdeadbeef, 10, 16, 0));
+  EXPECT_EQ("deadbeef", itoa_r(0xdeadbeef,  9, 16, 0));
+  EXPECT_EQ("deadbee",  itoa_r(0xdeadbeef,  8, 16, 0));
+  EXPECT_EQ("deadbe",   itoa_r(0xdeadbeef,  7, 16, 0));
+  EXPECT_EQ("beef",     itoa_r(0xbeef,      5, 16, 4));
+  EXPECT_EQ("0bee",     itoa_r(0xbeef,      5, 16, 5));
+  EXPECT_EQ("00be",     itoa_r(0xbeef,      5, 16, 6));
 
   // Test padding.
-  EXPECT_EQ("1", itoa_r_wrapper(1, 128, 10, 0));
-  EXPECT_EQ("1", itoa_r_wrapper(1, 128, 10, 1));
-  EXPECT_EQ("01", itoa_r_wrapper(1, 128, 10, 2));
-  EXPECT_EQ("001", itoa_r_wrapper(1, 128, 10, 3));
-  EXPECT_EQ("0001", itoa_r_wrapper(1, 128, 10, 4));
-  EXPECT_EQ("00001", itoa_r_wrapper(1, 128, 10, 5));
-  EXPECT_EQ("688", itoa_r_wrapper(0x688, 128, 16, 0));
-  EXPECT_EQ("688", itoa_r_wrapper(0x688, 128, 16, 1));
-  EXPECT_EQ("688", itoa_r_wrapper(0x688, 128, 16, 2));
-  EXPECT_EQ("688", itoa_r_wrapper(0x688, 128, 16, 3));
-  EXPECT_EQ("0688", itoa_r_wrapper(0x688, 128, 16, 4));
-  EXPECT_EQ("00688", itoa_r_wrapper(0x688, 128, 16, 5));
+  EXPECT_EQ("1", itoa_r(1, 128, 10, 0));
+  EXPECT_EQ("1", itoa_r(1, 128, 10, 1));
+  EXPECT_EQ("01", itoa_r(1, 128, 10, 2));
+  EXPECT_EQ("001", itoa_r(1, 128, 10, 3));
+  EXPECT_EQ("0001", itoa_r(1, 128, 10, 4));
+  EXPECT_EQ("00001", itoa_r(1, 128, 10, 5));
+  EXPECT_EQ("688", itoa_r(0x688, 128, 16, 0));
+  EXPECT_EQ("688", itoa_r(0x688, 128, 16, 1));
+  EXPECT_EQ("688", itoa_r(0x688, 128, 16, 2));
+  EXPECT_EQ("688", itoa_r(0x688, 128, 16, 3));
+  EXPECT_EQ("0688", itoa_r(0x688, 128, 16, 4));
+  EXPECT_EQ("00688", itoa_r(0x688, 128, 16, 5));
 }
 #endif  // defined(OS_POSIX) && !defined(OS_ANDROID)
 
 }  // namespace debug
 }  // namespace base