Remove C++11 specific version of SafeSNPrintf()

base/strings/safe_sprintf.h

 // 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.
 
 #ifndef BASE_STRINGS_SAFE_SPRINTF_H_
 #define BASE_STRINGS_SAFE_SPRINTF_H_
 
 #include "build/build_config.h"
 
 #include <stddef.h>
@@ skipping 86 matching lines @@
 // This ensures that the caller can always add one to the signed return code
 // in order to determine the amount of storage that needs to be allocated.
 //
 // While the code supports type checking and while it is generally very careful
 // to avoid printing incorrect values, it tends to be conservative in printing
 // as much as possible, even when given incorrect parameters. Typically, in
 // case of an error, the format string will not be expanded. (i.e. something
 // like SafeSPrintf(buf, "%p %d", 1, 2) results in "%p 2"). See above for
 // the use of RAW_CHECK() in debug builds, though.
 //
-// The pre-C++11 version cannot handle more than ten arguments.
-//
 // Basic example:
 //   char buf[20];
 //   base::strings::SafeSPrintf(buf, "The answer: %2d", 42);
 //
 // Example with dynamically sized buffer (async-signal-safe). This code won't
 // work on Visual studio, as it requires dynamically allocating arrays on the
 // stack. Consider picking a smaller value for |kMaxSize| if stack size is
 // limited and known. On the other hand, if the parameters to SafeSNPrintf()
 // are trusted and not controllable by the user, you can consider eliminating
 // the check for |kMaxSize| altogether. The current value of SSIZE_MAX is
@@ skipping 64 matching lines @@
 #if !defined(NDEBUG)
 // In debug builds, allow unit tests to artificially lower the kSSizeMax
 // constant that is used as a hard upper-bound for all buffers. In normal
 // use, this constant should always be std::numeric_limits<ssize_t>::max().
 BASE_EXPORT void SetSafeSPrintfSSizeMaxForTest(size_t max);
 BASE_EXPORT size_t GetSafeSPrintfSSizeMaxForTest();
 #endif
 
 }  // namespace internal
 
-#if __cplusplus >= 201103  // C++11
-
-template<typename... Args>
-ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt, Args... args) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = { args... };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-template<size_t N, typename... Args>
-ssize_t SafeSPrintf(char (&buf)[N], const char* fmt, Args... args) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = { args... };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-#else  // Pre-C++11
-
 // TODO(markus): C++11 has a much more concise and readable solution for
-//   expressing what we are doing here. Delete the fall-back code for older
-//   compilers as soon as we have fully switched to C++11.
+//   expressing what we are doing here.
 
 template<class T0, class T1, class T2, class T3, class T4,
          class T5, class T6, class T7, class T8, class T9>
 ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt,
                      T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4,
                      T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9) {
   // Use Arg() object to record type information and then copy arguments to an
   // array to make it easier to iterate over them.
   const internal::Arg arg_array[] = {
     arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9
@@ skipping 193 matching lines @@
   return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
 }
 
 template<size_t N, class T0>
 ssize_t SafeSPrintf(char (&buf)[N], const char* fmt, T0 arg0) {
   // Use Arg() object to record type information and then copy arguments to an
   // array to make it easier to iterate over them.
   const internal::Arg arg_array[] = { arg0 };
   return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
 }
-#endif
 
 // Fast-path when we don't actually need to substitute any arguments.
 BASE_EXPORT ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt);
 template<size_t N>
 inline ssize_t SafeSPrintf(char (&buf)[N], const char* fmt) {
   return SafeSNPrintf(buf, N, fmt);
 }
 
 }  // namespace strings
 }  // namespace base
 
 #endif  // BASE_STRINGS_SAFE_SPRINTF_H_