Enough hacks to make wstring printfs unneeded

base/strings/stringprintf.cc

 // Copyright 2013 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/strings/stringprintf.h"
 
 #include <errno.h>
 
 #include <vector>
 
@@ skipping 11 matching lines @@
 // large enough to accommodate the formatted string without truncation, they
 // return the number of characters that would be in the fully-formatted string
 // (vsnprintf, and vswprintf on Windows), or -1 (vswprintf on POSIX platforms).
 inline int vsnprintfT(char* buffer,
                       size_t buf_size,
                       const char* format,
                       va_list argptr) {
   return base::vsnprintf(buffer, buf_size, format, argptr);
 }
 
-#if defined(OS_WIN)
+/*#if defined(OS_WIN)
 inline int vsnprintfT(wchar_t* buffer,
                       size_t buf_size,
                       const wchar_t* format,
                       va_list argptr) {
   return base::vswprintf(buffer, buf_size, format, argptr);
 }
-#endif
+#endif*/
 
 // Templatized backend for StringPrintF/StringAppendF. This does not finalize
 // 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.
@@ skipping 62 matching lines @@
 
 std::string StringPrintf(const char* format, ...) {
   va_list ap;
   va_start(ap, format);
   std::string result;
   StringAppendV(&result, format, ap);
   va_end(ap);
   return result;
 }
 
-#if defined(OS_WIN)
+/*#if defined(OS_WIN)
 std::wstring StringPrintf(const wchar_t* format, ...) {
   va_list ap;
   va_start(ap, format);
   std::wstring result;
   StringAppendV(&result, format, ap);
   va_end(ap);
   return result;
 }
-#endif
+#endif*/
 
 std::string StringPrintV(const char* format, va_list ap) {
   std::string result;
   StringAppendV(&result, format, ap);
   return result;
 }
 
 const std::string& SStringPrintf(std::string* dst, const char* format, ...) {
   va_list ap;
   va_start(ap, format);
   dst->clear();
   StringAppendV(dst, format, ap);
   va_end(ap);
   return *dst;
 }
 
-#if defined(OS_WIN)
+/*#if defined(OS_WIN)
 const std::wstring& SStringPrintf(std::wstring* dst,
                                   const wchar_t* format, ...) {
   va_list ap;
   va_start(ap, format);
   dst->clear();
   StringAppendV(dst, format, ap);
   va_end(ap);
   return *dst;
 }
-#endif
+#endif*/
 
 void StringAppendF(std::string* dst, const char* format, ...) {
   va_list ap;
   va_start(ap, format);
   StringAppendV(dst, format, ap);
   va_end(ap);
 }
 
-#if defined(OS_WIN)
+/*#if defined(OS_WIN)
 void StringAppendF(std::wstring* dst, const wchar_t* format, ...) {
   va_list ap;
   va_start(ap, format);
   StringAppendV(dst, format, ap);
   va_end(ap);
 }
-#endif
+#endif*/
 
 void StringAppendV(std::string* dst, const char* format, va_list ap) {
   StringAppendVT(dst, format, ap);
 }
 
-#if defined(OS_WIN)
+/*#if defined(OS_WIN)
 void StringAppendV(std::wstring* dst, const wchar_t* format, va_list ap) {
   StringAppendVT(dst, format, ap);
 }
-#endif
+#endif*/
 
 }  // namespace base