diff --git a/rtc_base/string_encode.cc b/rtc_base/string_encode.cc
index da31ac08b3..7b2eda7051 100644
--- a/rtc_base/string_encode.cc
+++ b/rtc_base/string_encode.cc
@@ -14,6 +14,7 @@
 
 #include "rtc_base/arraysize.h"
 #include "rtc_base/checks.h"
+#include "rtc_base/string_utils.h"
 
 namespace rtc {
 
@@ -44,22 +45,25 @@ bool hex_decode(char ch, unsigned char* val) {
   return true;
 }
 
-size_t hex_encode_output_length(size_t srclen, char delimiter) {
-  return delimiter && srclen > 0 ? (srclen * 3 - 1) : (srclen * 2);
-}
-
-// hex_encode shows the hex representation of binary data in ascii, with
-// |delimiter| between bytes, or none if |delimiter| == 0.
-void hex_encode_with_delimiter(char* buffer,
-                               const char* csource,
-                               size_t srclen,
-                               char delimiter) {
-  RTC_DCHECK(buffer);
+// hex_encode, but separate each byte representation with a delimiter.
+// |delimiter| == 0 means no delimiter
+// If the buffer is too short, we return 0
+size_t hex_encode_with_delimiter(char* buffer,
+                                 size_t buflen,
+                                 const char* csource,
+                                 size_t srclen,
+                                 char delimiter) {
+  RTC_DCHECK(buffer);  // TODO(kwiberg): estimate output size
+  if (buflen == 0)
+    return 0;
 
   // Init and check bounds.
   const unsigned char* bsource =
       reinterpret_cast<const unsigned char*>(csource);
   size_t srcpos = 0, bufpos = 0;
+  size_t needed = delimiter ? (srclen * 3) : (srclen * 2 + 1);
+  if (buflen < needed)
+    return 0;
 
   while (srcpos < srclen) {
     unsigned char ch = bsource[srcpos++];
@@ -73,6 +77,10 @@ void hex_encode_with_delimiter(char* buffer,
       ++bufpos;
     }
   }
+
+  // Null terminate.
+  buffer[bufpos] = '\0';
+  return bufpos;
 }
 
 }  // namespace
@@ -88,11 +96,12 @@ std::string hex_encode(const char* source, size_t srclen) {
 std::string hex_encode_with_delimiter(const char* source,
                                       size_t srclen,
                                       char delimiter) {
-  std::string s(hex_encode_output_length(srclen, delimiter), 0);
-  // TODO(nisse): When we can use C++17, switch the below hack with begin to
-  // just s.data().
-  hex_encode_with_delimiter(&*s.begin(), source, srclen, delimiter);
-  return s;
+  const size_t kBufferSize = srclen * 3;
+  char* buffer = STACK_ARRAY(char, kBufferSize);
+  size_t length =
+      hex_encode_with_delimiter(buffer, kBufferSize, source, srclen, delimiter);
+  RTC_DCHECK(srclen == 0 || length > 0);
+  return std::string(buffer, length);
 }
 
 size_t hex_decode(char* cbuffer,
diff --git a/rtc_base/string_utils.h b/rtc_base/string_utils.h
index 5b5d33c148..bc332846a4 100644
--- a/rtc_base/string_utils.h
+++ b/rtc_base/string_utils.h
@@ -21,15 +21,31 @@
 #include <wchar.h>
 #include <windows.h>
 
+#define alloca _alloca
 #endif  // WEBRTC_WIN
 
 #if defined(WEBRTC_POSIX)
+#ifdef BSD
 #include <stdlib.h>
+#else  // BSD
+#include <alloca.h>
+#endif  // !BSD
 #include <strings.h>
 #endif  // WEBRTC_POSIX
 
 #include <string>
 
+///////////////////////////////////////////////////////////////////////////////
+// Generic string/memory utilities
+///////////////////////////////////////////////////////////////////////////////
+
+#define STACK_ARRAY(TYPE, LEN) \
+  static_cast<TYPE*>(::alloca((LEN) * sizeof(TYPE)))
+
+///////////////////////////////////////////////////////////////////////////////
+// Traits simplifies porting string functions to be CTYPE-agnostic
+///////////////////////////////////////////////////////////////////////////////
+
 namespace rtc {
 
 const size_t SIZE_UNKNOWN = static_cast<size_t>(-1);
@@ -49,10 +65,9 @@ size_t strcpyn(char* buffer,
 inline std::wstring ToUtf16(const char* utf8, size_t len) {
   int len16 = ::MultiByteToWideChar(CP_UTF8, 0, utf8, static_cast<int>(len),
                                     nullptr, 0);
-  std::wstring ws(len16, 0);
-  ::MultiByteToWideChar(CP_UTF8, 0, utf8, static_cast<int>(len), &*ws.begin(),
-                        ws.size());
-  return ws;
+  wchar_t* ws = STACK_ARRAY(wchar_t, len16);
+  ::MultiByteToWideChar(CP_UTF8, 0, utf8, static_cast<int>(len), ws, len16);
+  return std::wstring(ws, len16);
 }
 
 inline std::wstring ToUtf16(const std::string& str) {
@@ -62,10 +77,10 @@ inline std::wstring ToUtf16(const std::string& str) {
 inline std::string ToUtf8(const wchar_t* wide, size_t len) {
   int len8 = ::WideCharToMultiByte(CP_UTF8, 0, wide, static_cast<int>(len),
                                    nullptr, 0, nullptr, nullptr);
-  std::string ns(len8, 0);
-  ::WideCharToMultiByte(CP_UTF8, 0, wide, static_cast<int>(len), &*ns.begin(),
-                        ns.size(), nullptr, nullptr);
-  return ns;
+  char* ns = STACK_ARRAY(char, len8);
+  ::WideCharToMultiByte(CP_UTF8, 0, wide, static_cast<int>(len), ns, len8,
+                        nullptr, nullptr);
+  return std::string(ns, len8);
 }
 
 inline std::string ToUtf8(const wchar_t* wide) {