Move base::va_copy from a function to a macro.

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 897 matching lines @@
 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;
-  base::va_copy(backup_ap, ap);
+  GG_VA_COPY(backup_ap, ap);
 
 #if !defined(OS_WIN)
   errno = 0;
 #endif
   int result = vsnprintfT(stack_buf, arraysize(stack_buf), format, backup_ap);
   va_end(backup_ap);
 
   if (result >= 0 && result < static_cast<int>(arraysize(stack_buf))) {
     // It fit.
     dst->append(stack_buf, result);
@@ skipping 26 matching lines @@
       // 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.
-    base::va_copy(backup_ap, ap);
+    GG_VA_COPY(backup_ap, ap);
 
     result = vsnprintfT(&mem_buf[0], mem_length, format, ap);
     va_end(backup_ap);
 
     if ((result >= 0) && (result < mem_length)) {
       // It fit.
       dst->append(&mem_buf[0], result);
       return;
     }
   }
@@ skipping 673 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;
 }