Revert of SkStringPrintf and SkString::printf now are no longer limted by a static buffer

src/core/SkString.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkAtomics.h"
 #include "SkString.h"
@@ skipping 15 matching lines @@
 
 #define ARGS_TO_BUFFER(format, buffer, size, written)      \
     do {                                                   \
         va_list args;                                      \
         va_start(args, format);                            \
         written = VSNPRINTF(buffer, size, format, args);   \
         SkASSERT(written >= 0 && written < SkToInt(size)); \
         va_end(args);                                      \
     } while (0)
 
-#ifdef SK_BUILD_FOR_WIN
-#define V_SKSTRING_PRINTF(output, format)                               \
-    do {                                                                \
-        va_list args;                                                   \
-        va_start(args, format);                                         \
-        char buffer[kBufferSize];                                       \
-        int length = _vsnprintf_s(buffer, sizeof(buffer),               \
-                                  _TRUNCATE, format, args);             \
-        va_end(args);                                                   \
-        if (length >= 0 && length < (int)sizeof(buffer)) {              \
-            output.set(buffer, length);                                 \
-            break;                                                      \
-        }                                                               \
-        va_start(args, format);                                         \
-        length = _vscprintf(format, args);                              \
-        va_end(args);                                                   \
-        output.resize((size_t)length);                                  \
-        va_start(args, format);                                         \
-        SkDEBUGCODE(int check = ) _vsnprintf_s(output.writable_str(),   \
-                                               length + 1, _TRUNCATE,   \
-                                               format, args);           \
-        va_end(args);                                                   \
-        SkASSERT(check == length);                                      \
-        SkASSERT(output[length] == '\0');                               \
-    } while (false)
-#else
-#define V_SKSTRING_PRINTF(output, format)                               \
-    do {                                                                \
-        va_list args;                                                   \
-        va_start(args, format);                                         \
-        char buffer[kBufferSize];                                       \
-        int length = vsnprintf(buffer, sizeof(buffer), format, args);   \
-        va_end(args);                                                   \
-        if (length < 0) {                                               \
-            break;                                                      \
-        }                                                               \
-        if (length < (int)sizeof(buffer)) {                             \
-            output.set(buffer, length);                                 \
-            break;                                                      \
-        }                                                               \
-        output.resize((size_t)length);                                  \
-        va_start(args, format);                                         \
-        SkDEBUGCODE(int check = ) vsnprintf(output.writable_str(),      \
-                                            length + 1, format, args);  \
-        va_end(args);                                                   \
-        SkASSERT(check == length);                                      \
-        SkASSERT(output[length] == '\0');                               \
-    } while (false)
-#endif
-
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkStrEndsWith(const char string[], const char suffixStr[]) {
     SkASSERT(string);
     SkASSERT(suffixStr);
     size_t  strLen = strlen(string);
     size_t  suffixLen = strlen(suffixStr);
     return  strLen >= suffixLen &&
             !strncmp(string + strLen - suffixLen, suffixStr, suffixLen);
 }
@@ skipping 460 matching lines @@
     this->insert(offset, p, buffer + sizeof(buffer) - p);
 }
 
 void SkString::insertScalar(size_t offset, SkScalar value) {
     char    buffer[SkStrAppendScalar_MaxSize];
     char*   stop = SkStrAppendScalar(buffer, value);
     this->insert(offset, buffer, stop - buffer);
 }
 
 void SkString::printf(const char format[], ...) {
-    V_SKSTRING_PRINTF((*this), format);
+    char    buffer[kBufferSize];
+    int length;
+    ARGS_TO_BUFFER(format, buffer, kBufferSize, length);
+
+    this->set(buffer, length);
 }
 
 void SkString::appendf(const char format[], ...) {
     char    buffer[kBufferSize];
     int length;
     ARGS_TO_BUFFER(format, buffer, kBufferSize, length);
 
     this->append(buffer, length);
 }
 
@@ skipping 55 matching lines @@
     this->validate();
     other.validate();
 
     SkTSwap<Rec*>(fRec, other.fRec);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkString SkStringPrintf(const char* format, ...) {
     SkString formattedOutput;
-    V_SKSTRING_PRINTF(formattedOutput, format);
+    char buffer[kBufferSize];
+    SK_UNUSED int length;
+    ARGS_TO_BUFFER(format, buffer, kBufferSize, length);
+    formattedOutput.set(buffer);
     return formattedOutput;
 }
 
 void SkStrSplit(const char* str, const char* delimiters, SkStrSplitMode splitMode,
                 SkTArray<SkString>* out) {
     if (splitMode == kCoalesce_SkStrSplitMode) {
         // Skip any delimiters.
         str += strspn(str, delimiters);
     }
     if (!*str) {
@@ skipping 16 matching lines @@
             str += strspn(str, delimiters);
         } else {
             // Skip one delimiter.
             str += 1;
         }
     }
 }
 
 #undef VSNPRINTF
 #undef SNPRINTF