change impl to explicitly store length as u32, rather than size_t, so we keep a packed struct on 64…

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 "SkString.h"
@@ skipping 171 matching lines @@
     return string;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // the 3 values are [length] [refcnt] [terminating zero data]
 const SkString::Rec SkString::gEmptyRec = { 0, 0, 0 };
 
 #define SizeOfRec()     (gEmptyRec.data() - (const char*)&gEmptyRec)
 
+static uint32_t trim_size_t_to_u32(size_t value) {
+    if (sizeof(size_t) > sizeof(uint32_t)) {

[bungeman-skia, 2013/06/04 15:30:45]

I just added SkTFitsIn<T> for exactly this kind of thing. Would that be useful
here? It seems like it might potentially make this and some of the following
bits easier to follow.

+        if (value > SK_MaxU32) {
+            value = SK_MaxU32;
+        }
+    }
+    return (uint32_t)value;
+}
+
+static size_t check_add32(size_t base, size_t extra) {
+    SkASSERT(base <= SK_MaxU32);
+    if (sizeof(size_t) > sizeof(uint32_t)) {
+        if (base + extra > SK_MaxU32) {
+            extra = SK_MaxU32 - base;
+        }
+    }
+    return extra;
+}
+
 SkString::Rec* SkString::AllocRec(const char text[], size_t len) {
     Rec* rec;
 
     if (0 == len) {
         rec = const_cast<Rec*>(&gEmptyRec);
     } else {
+        len = trim_size_t_to_u32(len);
+
         // add 1 for terminating 0, then align4 so we can have some slop when growing the string
         rec = (Rec*)sk_malloc_throw(SizeOfRec() + SkAlign4(len + 1));
-        rec->fLength = len;
+        rec->fLength = SkToU32(len);
         rec->fRefCnt = 1;
         if (text) {
             memcpy(rec->data(), text, len);
         }
         rec->data()[len] = 0;
     }
     return rec;
 }
 
 SkString::Rec* SkString::RefRec(Rec* src) {
@@ skipping 138 matching lines @@
         }
     }
     return fRec->data();
 }
 
 void SkString::set(const char text[]) {
     this->set(text, text ? strlen(text) : 0);
 }
 
 void SkString::set(const char text[], size_t len) {
+    len = trim_size_t_to_u32(len);
+
     if (0 == len) {
         this->reset();
     } else if (1 == fRec->fRefCnt && len <= fRec->fLength) {
         // should we resize if len <<<< fLength, to save RAM? (e.g. len < (fLength>>1))?
         // just use less of the buffer without allocating a smaller one
         char* p = this->writable_str();
         if (text) {
             memcpy(p, text, len);
         }
         p[len] = 0;
-        fRec->fLength = len;
+        fRec->fLength = SkToU32(len);
     } else if (1 == fRec->fRefCnt && (fRec->fLength >> 2) == (len >> 2)) {
         // we have spare room in the current allocation, so don't alloc a larger one
         char* p = this->writable_str();
         if (text) {
             memcpy(p, text, len);
         }
         p[len] = 0;
-        fRec->fLength = len;
+        fRec->fLength = SkToU32(len);
     } else {
         SkString tmp(text, len);
         this->swap(tmp);
     }
 }
 
 void SkString::setUTF16(const uint16_t src[]) {
     int count = 0;
 
     while (src[count]) {
         count += 1;
     }
-    setUTF16(src, count);
+    this->setUTF16(src, count);
 }
 
 void SkString::setUTF16(const uint16_t src[], size_t count) {
+    count = trim_size_t_to_u32(count);
+
     if (0 == count) {
         this->reset();
     } else if (count <= fRec->fLength) {
         // should we resize if len <<<< fLength, to save RAM? (e.g. len < (fLength>>1))
         if (count < fRec->fLength) {
             this->resize(count);
         }
         char* p = this->writable_str();
         for (size_t i = 0; i < count; i++) {
             p[i] = SkToU8(src[i]);
@@ skipping 13 matching lines @@
 void SkString::insert(size_t offset, const char text[]) {
     this->insert(offset, text, text ? strlen(text) : 0);
 }
 
 void SkString::insert(size_t offset, const char text[], size_t len) {
     if (len) {
         size_t length = fRec->fLength;
         if (offset > length) {
             offset = length;
         }
+        
+        // Check if length + len exceeds 32bits, we trim len
+        len = check_add32(length, len);
+        if (0 == len) {
+            return;
+        }
 
         /*  If we're the only owner, and we have room in our allocation for the insert,
             do it in place, rather than allocating a new buffer.
 
             To know we have room, compare the allocated sizes
             beforeAlloc = SkAlign4(length + 1)
             afterAlloc  = SkAligh4(length + 1 + len)
             but SkAlign4(x) is (x + 3) >> 2 << 2
             which is equivalent for testing to (length + 1 + 3) >> 2 == (length + 1 + 3 + len) >> 2
             and we can then eliminate the +1+3 since that doesn't affec the answer
         */
         if (1 == fRec->fRefCnt && (length >> 2) == ((length + len) >> 2)) {
             char* dst = this->writable_str();
 
             if (offset < length) {
                 memmove(dst + offset + len, dst + offset, length - offset);
             }
             memcpy(dst + offset, text, len);
 
             dst[length + len] = 0;
-            fRec->fLength = length + len;
+            fRec->fLength = SkToU32(length + len);
         } else {
             /*  Seems we should use realloc here, since that is safe if it fails
                 (we have the original data), and might be faster than alloc/copy/free.
             */
             SkString    tmp(fRec->fLength + len);
             char*       dst = tmp.writable_str();
 
             if (offset > 0) {
                 memcpy(dst, fRec->data(), offset);
             }
@@ skipping 152 matching lines @@
 SkString SkStringPrintf(const char* format, ...) {
     SkString formattedOutput;
     char buffer[kBufferSize];
     ARGS_TO_BUFFER(format, buffer, kBufferSize);
     formattedOutput.set(buffer);
     return formattedOutput;
 }
 
 #undef VSNPRINTF
 #undef SNPRINTF