Fix a bug where we reused a va_list across multiple calls.

base/string_util.cc

 // Copyright (c) 2006-2008 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 "base/string_util.h"
 
 #include "build/build_config.h"
 
 #include <ctype.h>
 #include <errno.h>
@@ skipping 925 matching lines @@
 // the va_list, the caller is expected to do that.
 template <class StringType>
 static void StringAppendVT(StringType* dst,
                            const typename StringType::value_type* format,
                            va_list ap) {
   // First try with a small fixed size buffer.
   // This buffer size should be kept in sync with StringUtilTest.GrowBoundary
   // and StringUtilTest.StringPrintfBounds.
   typename StringType::value_type stack_buf[1024];
 
-  va_list backup_ap;
-  GG_VA_COPY(backup_ap, ap);
+  va_list ap_copy;
+  GG_VA_COPY(ap_copy, ap);
 
 #if !defined(OS_WIN)
   errno = 0;
 #endif
-  int result = vsnprintfT(stack_buf, arraysize(stack_buf), format, backup_ap);
-  va_end(backup_ap);
+  int result = vsnprintfT(stack_buf, arraysize(stack_buf), format, ap_copy);
+  va_end(ap_copy);
 
   if (result >= 0 && result < static_cast<int>(arraysize(stack_buf))) {
     // It fit.
     dst->append(stack_buf, result);
     return;
   }
 
   // Repeatedly increase buffer size until it fits.
   int mem_length = arraysize(stack_buf);
   while (true) {
@@ skipping 19 matching lines @@
     if (mem_length > 32 * 1024 * 1024) {
       // That should be plenty, don't try anything larger.  This protects
       // against huge allocations when using vsnprintfT implementations that
       // return -1 for reasons other than overflow without setting errno.
       DLOG(WARNING) << "Unable to printf the requested string due to size.";
       return;
     }
 
     std::vector<typename StringType::value_type> mem_buf(mem_length);
 
-    // Restore the va_list before we use it again.
-    GG_VA_COPY(backup_ap, ap);
-
-    result = vsnprintfT(&mem_buf[0], mem_length, format, ap);
-    va_end(backup_ap);
+    // NOTE: You can only use a va_list once.  Since we're in a while loop, we
+    // need to make a new copy each time so we don't use up the original.
+    GG_VA_COPY(ap_copy, ap);
+    result = vsnprintfT(&mem_buf[0], mem_length, format, ap_copy);

[Evan Martin, 2009/08/24 20:28:50]

(note for brett: aside from the variable rename, this is the actual real change
made by this code)

+    va_end(ap_copy);
 
     if ((result >= 0) && (result < mem_length)) {
       // It fit.
       dst->append(&mem_buf[0], result);
       return;
     }
   }
 }
 
 namespace {
@@ skipping 657 matching lines @@
   // Each input byte creates two output hex characters.
   std::string ret(size * 2, '\0');
 
   for (size_t i = 0; i < size; ++i) {
     char b = reinterpret_cast<const char*>(bytes)[i];
     ret[(i * 2)] = kHexChars[(b >> 4) & 0xf];
     ret[(i * 2) + 1] = kHexChars[b & 0xf];
   }
   return ret;
 }