Guard against most unintentionally ephemeral SkAutoFoo instantiations.

include/core/SkTSearch.h

 
 /*
  * 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.
  */
 
 
 #ifndef SkTSearch_DEFINED
 #define SkTSearch_DEFINED
 
 #include "SkTypes.h"
+#include <ctype.h>
 
 /**
  *  All of the SkTSearch variants want to return the index (0...N-1) of the
  *  found element, or the bit-not of where to insert the element.
  *
  *  At a simple level, if the return value is negative, it was not found.
  *
  *  For clients that want to insert the new element if it was not found, use
  *  the following logic:
  *
@@ skipping 94 matching lines @@
 int SkStrLCSearch(const char*const* base, int count, const char target[],
                   size_t elemSize);
 
 /** Helper class to convert a string to lower-case, but only modifying the ascii
     characters. This makes the routine very fast and never changes the string
     length, but it is not suitable for linguistic purposes. Normally this is
     used for buiding and searching string tables.
 */
 class SkAutoAsciiToLC {
 public:
-    SkAutoAsciiToLC(const char str[], size_t len = (size_t)-1);
-    ~SkAutoAsciiToLC();
+    SkAutoAsciiToLC(const char str[], size_t len = (size_t)-1) {

[reed1, 2013/11/15 18:20:12]

Not sure I agree with this one.

1. This class does *not* perform its magic in its destructor as the AutoFoo guys
do, but it is used to access its lc() method. Seems less likely a caller would
make this mistake, and certainly it would not lead to any bug, unlike the Auto
guys.

2. The macro seems to force us to inline the code, which is overkill/bloaty for
this guy imho.

[mtklein, 2013/11/15 18:28:14]

Reverted.

+        // see if we need to compute the length
+        if ((long)len < 0) {
+            len = strlen(str);
+        }
+        fLength = len;
+
+        // assign lc to our preallocated storage if len is small enough, or allocate
+        // it on the heap
+        char*   lc;
+        if (len <= STORAGE) {
+            lc = fStorage;
+        } else {
+            lc = (char*)sk_malloc_throw(len + 1);
+        }
+        fLC = lc;
+
+        // convert any asii to lower-case. we let non-ascii (utf8) chars pass
+        // through unchanged
+        for (int i = (int)(len - 1); i >= 0; --i) {
+            int c = str[i];
+            if ((c & 0x80) == 0) {   // is just ascii
+                c = tolower(c);
+            }
+            lc[i] = c;
+        }
+        lc[len] = 0;
+    }
+    ~SkAutoAsciiToLC() {
+        if (fLC != fStorage) {
+            sk_free(fLC);
+        }
+    }
 
     const char* lc() const { return fLC; }
     size_t      length() const { return fLength; }
 
 private:
     char*   fLC;    // points to either the heap or fStorage
     size_t  fLength;
     enum {
         STORAGE = 64
     };
     char    fStorage[STORAGE+1];
 };
+#define SkAutoAsciiToLC(...) SK_REQUIRE_LOCAL_VAR(SkAutoAsciiToLC)
 
 // Helper when calling qsort with a compare proc that has typed its arguments
 #define SkCastForQSort(compare) reinterpret_cast<int (*)(const void*, const void*)>(compare)
 
 #endif