Remove the remainder of the skia source code from the Chromium repo....

skia/sgl/SkString.cpp

Index: skia/sgl/SkString.cpp
===================================================================
--- skia/sgl/SkString.cpp	(revision 16859)
+++ skia/sgl/SkString.cpp	(working copy)
@@ -1,628 +0,0 @@
-/* libs/graphics/sgl/SkString.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
-**
-**     http://www.apache.org/licenses/LICENSE-2.0 
-**
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
-** limitations under the License.
-*/
-
-#include "SkString.h"
-#include "SkFixed.h"
-#include "SkUtils.h"
-#include <stdarg.h>
-
-bool SkStrStartsWith(const char string[], const char prefix[])
-{
-    SkASSERT(string);
-    SkASSERT(prefix);
-    return !strncmp(string, prefix, strlen(prefix));
-}
-
-bool SkStrEndsWith(const char string[], const char suffix[])
-{
-    SkASSERT(string);
-    SkASSERT(suffix);
-    size_t  strLen = strlen(string);
-    size_t  suffixLen = strlen(suffix);
-    return  strLen >= suffixLen &&
-            !strncmp(string + strLen - suffixLen, suffix, suffixLen);
-}
-
-int SkStrStartsWithOneOf(const char string[], const char prefixes[])
-{
-    int index = 0;
-    do {
-        const char* limit = strchr(prefixes, '\0');
-        if (!strncmp(string, prefixes, limit - prefixes))
-            return index;
-        prefixes = limit + 1;
-        index++;
-    } while (prefixes[0]);
-    return -1;
-}
-
-char* SkStrAppendS32(char string[], int32_t dec)
-{
-    SkDEBUGCODE(char* start = string;)
-
-    char    buffer[SkStrAppendS32_MaxSize];
-    char*   p = buffer + sizeof(buffer);
-    bool    neg = false;
-
-    if (dec < 0)
-    {
-        neg = true;
-        dec = -dec;
-    }
-    do {
-        *--p = SkToU8('0' + dec % 10);
-        dec /= 10;
-    } while (dec != 0);
-    if (neg)
-        *--p = '-';
-
-    SkASSERT(p >= buffer);
-    char* stop = buffer + sizeof(buffer);
-    while (p < stop)
-        *string++ = *p++;
-
-    SkASSERT(string - start <= SkStrAppendS32_MaxSize);
-    return string;
-}
-
-char* SkStrAppendScalar(char string[], SkScalar value)
-{
-    SkDEBUGCODE(char* start = string;)
-
-    SkFixed x = SkScalarToFixed(value);
-
-    if (x < 0)
-    {
-        *string++ = '-';
-        x = -x;
-    }
-
-    unsigned frac = x & 0xFFFF;
-    x >>= 16;
-    if (frac == 0xFFFF) // need to do this to "round up", since 65535/65536 is closer to 1 than to .9999
-    {
-        x += 1;
-        frac = 0;
-    }
-    string = SkStrAppendS32(string, x);
-
-    // now handle the fractional part (if any)
-    if (frac)
-    {
-        static const uint16_t   gTens[] = { 1000, 100, 10, 1 };
-        const uint16_t*         tens = gTens;
-
-        x = SkFixedRound(frac * 10000);
-        SkASSERT(x <= 10000);
-        if (x == 10000) {
-            x -= 1;
-        }
-        *string++ = '.';
-        do {
-            unsigned powerOfTen = *tens++;
-            *string++ = SkToU8('0' + x / powerOfTen);
-            x %= powerOfTen;
-        } while (x != 0);
-    }
-    
-    SkASSERT(string - start <= SkStrAppendScalar_MaxSize);
-    return string;
-}
-
-////////////////////////////////////////////////////////////////////////////////////
-
-#define kMaxRefCnt_SkString     SK_MaxU16
-
-// the 3 values are [length] [refcnt] [terminating zero data]
-const SkString::Rec SkString::gEmptyRec = { 0, 0, 0 };
-
-#define SizeOfRec()     (gEmptyRec.data() - (const char*)&gEmptyRec)
-
-SkString::Rec* SkString::AllocRec(const char text[], U16CPU len)
-{
-    Rec* rec;
-
-    if (len == 0)
-        rec = const_cast<Rec*>(&gEmptyRec);
-    else
-    {
-        // 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 = SkToU16(len);
-        rec->fRefCnt = 1;
-        if (text)
-            memcpy(rec->data(), text, len);
-        rec->data()[len] = 0;
-    }
-    return rec;
-}
-
-SkString::Rec* SkString::RefRec(Rec* src)
-{
-    if (src != &gEmptyRec)
-    {
-        if (src->fRefCnt == kMaxRefCnt_SkString) {
-            src = AllocRec(src->data(), src->fLength);
-        } else
-            src->fRefCnt += 1;
-    }
-    return src;
-}
-
-#ifdef SK_DEBUG
-void SkString::validate() const
-{
-    // make sure know one has written over our global
-    SkASSERT(gEmptyRec.fLength == 0);
-    SkASSERT(gEmptyRec.fRefCnt == 0);
-    SkASSERT(gEmptyRec.data()[0] == 0);
-
-    if (fRec != &gEmptyRec)
-    {
-        SkASSERT(fRec->fLength > 0);
-        SkASSERT(fRec->fRefCnt > 0);
-        SkASSERT(fRec->data()[fRec->fLength] == 0);
-    }
-    SkASSERT(fStr == c_str());
-}
-#endif
-
-///////////////////////////////////////////////////////////////////////
-
-SkString::SkString() : fRec(const_cast<Rec*>(&gEmptyRec)) {
-#ifdef SK_DEBUG
-    fStr = fRec->data();
-#endif
-}
-
-SkString::SkString(size_t len)
-{
-    SkASSERT(SkToU16(len) == len);  // can't handle larger than 64K
-
-    fRec = AllocRec(NULL, (U16CPU)len);
-#ifdef SK_DEBUG
-    fStr = fRec->data();
-#endif
-}
-
-SkString::SkString(const char text[])
-{
-    size_t  len = text ? strlen(text) : 0;
-
-    fRec = AllocRec(text, (U16CPU)len);
-#ifdef SK_DEBUG
-    fStr = fRec->data();
-#endif
-}
-
-SkString::SkString(const char text[], size_t len)
-{
-    fRec = AllocRec(text, (U16CPU)len);
-#ifdef SK_DEBUG
-    fStr = fRec->data();
-#endif
-}
-
-SkString::SkString(const SkString& src)
-{
-    src.validate();
-
-    fRec = RefRec(src.fRec);
-#ifdef SK_DEBUG
-    fStr = fRec->data();
-#endif
-}
-
-SkString::~SkString()
-{
-    this->validate();
-
-    if (fRec->fLength)
-    {
-        SkASSERT(fRec->fRefCnt > 0);
-        if (--fRec->fRefCnt == 0)
-            sk_free(fRec);
-    }
-}
-
-bool SkString::equals(const SkString& src) const
-{
-    return fRec == src.fRec || this->equals(src.c_str(), src.size());
-}
-
-bool SkString::equals(const char text[]) const
-{
-    return this->equals(text, text ? strlen(text) : 0);
-}
-
-bool SkString::equals(const char text[], size_t len) const
-{
-    SkASSERT(len == 0 || text != NULL);
-
-    return fRec->fLength == len && !memcmp(fRec->data(), text, len);
-}
-
-SkString& SkString::operator=(const SkString& src)
-{
-    this->validate();
-
-    if (fRec != src.fRec)
-    {
-        SkString    tmp(src);
-        this->swap(tmp);
-    }
-    return *this;
-}
-
-void SkString::reset()
-{
-    this->validate();
-
-    if (fRec->fLength)
-    {
-        SkASSERT(fRec->fRefCnt > 0);
-        if (--fRec->fRefCnt == 0)
-            sk_free(fRec);
-    }
-
-    fRec = const_cast<Rec*>(&gEmptyRec);
-#ifdef SK_DEBUG
-    fStr = fRec->data();
-#endif
-}
-
-char* SkString::writable_str()
-{
-    this->validate();
-
-    if (fRec->fLength)
-    {
-        if (fRec->fRefCnt > 1)
-        {
-            fRec->fRefCnt -= 1;
-            fRec = AllocRec(fRec->data(), fRec->fLength);
-        #ifdef SK_DEBUG
-            fStr = fRec->data();
-        #endif
-        }
-    }
-    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)
-{
-    if (len == 0)
-        this->reset();
-    else if (fRec->fRefCnt == 1 && 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 = SkToU16(len);
-    }
-    else if (fRec->fRefCnt == 1 && ((unsigned)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 = SkToU16(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);
-}
-
-void SkString::setUTF16(const uint16_t src[], size_t count)
-{
-    if (count == 0)
-        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]);
-        p[count] = 0;
-    }
-    else
-    {
-        SkString    tmp(count); // puts a null terminator at the end of the string
-        char*       p = tmp.writable_str();
-
-        for (size_t i = 0; i < count; i++)
-            p[i] = SkToU8(src[i]);
-
-        this->swap(tmp);
-    }
-}
-
-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;
-
-        /*  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 (fRec->fRefCnt == 1 && (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 = SkToU16(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);
-            memcpy(dst + offset, text, len);
-            if (offset < fRec->fLength)
-                memcpy(dst + offset + len, fRec->data() + offset, fRec->fLength - offset);
-
-            this->swap(tmp);
-        }
-    }
-}
-
-void SkString::insertUnichar(size_t offset, SkUnichar uni)
-{
-    char    buffer[kMaxBytesInUTF8Sequence];
-    size_t  len = SkUTF8_FromUnichar(uni, buffer);
-
-    if (len)
-        this->insert(offset, buffer, len);
-}
-
-void SkString::insertS32(size_t offset, int32_t dec)
-{
-    char    buffer[SkStrAppendS32_MaxSize];
-    char*   stop = SkStrAppendS32(buffer, dec);
-    this->insert(offset, buffer, stop - buffer);
-}
-
-void SkString::insertHex(size_t offset, uint32_t hex, int minDigits)
-{
-    minDigits = SkPin32(minDigits, 0, 8);
-    
-    static const char gHex[] = "0123456789ABCDEF";
-
-    char    buffer[8];
-    char*   p = buffer + sizeof(buffer);
-
-    do {
-        *--p = gHex[hex & 0xF];
-        hex >>= 4;
-        minDigits -= 1;
-    } while (hex != 0);
-    while (--minDigits >= 0)
-        *--p = '0';
-
-    SkASSERT(p >= buffer);
-    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);
-}
-
-///////////////////////////////////////////////////////////////////////////
-
-//#include <stdarg.h>
-#if defined(SK_BUILD_FOR_WIN) || defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_UNIX)
-    #include <stdio.h>
-#endif
-
-void SkString::printf(const char format[], ...)
-{
-    static const size_t kBufferSize = 100;
-
-    char    buffer[kBufferSize + 1];
-
-#ifdef SK_BUILD_FOR_WIN
-    va_list args;
-    va_start(args, format);
-    _vsnprintf(buffer, kBufferSize, format, args);
-    va_end(args);
-#elif defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_UNIX)
-    va_list args;
-    va_start(args, format);
-    vsnprintf(buffer, kBufferSize, format, args);
-    va_end(args);
-#else
-    buffer[0] = 0;
-#endif
-
-    this->set(buffer, strlen(buffer));
-}
-
-///////////////////////////////////////////////////////////////////////////
-
-void SkString::remove(size_t offset, size_t length)
-{
-    size_t size = this->size();
-
-    if (offset < size)
-    {
-        if (offset + length > size)
-            length = size - offset;
-        if (length > 0)
-        {
-            SkASSERT(size > length);
-            SkString    tmp(size - length);
-            char*       dst = tmp.writable_str();
-            const char* src = this->c_str();
-
-            if (offset)
-            {
-                SkASSERT(offset <= tmp.size());
-                memcpy(dst, src, offset);
-            }
-            size_t tail = size - offset - length;
-            SkASSERT((int32_t)tail >= 0);
-            if (tail)
-            {
-        //      SkASSERT(offset + length <= tmp.size());
-                memcpy(dst + offset, src + offset + length, tail);
-            }
-            SkASSERT(dst[tmp.size()] == 0);
-            this->swap(tmp);
-        }
-    }
-}
-
-void SkString::swap(SkString& other)
-{
-    this->validate();
-    other.validate();
-
-    SkTSwap<Rec*>(fRec, other.fRec);
-#ifdef SK_DEBUG
-    SkTSwap<const char*>(fStr, other.fStr);
-#endif
-}
-
-/////////////////////////////////////////////////////////////////////////////////
-
-SkAutoUCS2::SkAutoUCS2(const char utf8[])
-{
-    size_t len = strlen(utf8);
-    fUCS2 = (uint16_t*)sk_malloc_throw((len + 1) * sizeof(uint16_t));
-
-    uint16_t* dst = fUCS2;
-    for (;;)
-    {
-        SkUnichar   uni = SkUTF8_NextUnichar(&utf8);
-        *dst++ = SkToU16(uni);
-        if (uni == 0)
-            break;
-    }
-    fCount = (int)(dst - fUCS2);
-}
-
-SkAutoUCS2::~SkAutoUCS2()
-{
-    delete[] fUCS2;
-}
-
-/////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////
-
-#ifdef SK_DEBUG
-
-void SkString::UnitTest()
-{
-#ifdef SK_SUPPORT_UNITTEST
-    SkString    a;
-    SkString    b((size_t)0);
-    SkString    c("");
-    SkString    d(NULL, 0);
-
-    SkASSERT(a.isEmpty());
-    SkASSERT(a == b && a == c && a == d);
-
-    a.set("hello");
-    b.set("hellox", 5);
-    c.set(a);
-    d.resize(5);
-    memcpy(d.writable_str(), "helloz", 5);
-
-    SkASSERT(!a.isEmpty());
-    SkASSERT(a.size() == 5);
-    SkASSERT(a == b && a == c && a == d);
-    SkASSERT(a.equals("hello", 5));
-    SkASSERT(a.equals("hello"));
-    SkASSERT(!a.equals("help"));
-
-    SkString    e(a);
-    SkString    f("hello");
-    SkString    g("helloz", 5);
-
-    SkASSERT(a == e && a == f && a == g);
-
-    b.set("world");
-    c = b;
-    SkASSERT(a != b && a != c && b == c);
-
-    a.append(" world");
-    e.append("worldz", 5);
-    e.insert(5, " ");
-    f.set("world");
-    f.prepend("hello ");
-    SkASSERT(a.equals("hello world") && a == e && a == f);
-
-    a.reset();
-    b.resize(0);
-    SkASSERT(a.isEmpty() && b.isEmpty() && a == b);
-
-    a.set("a");
-    a.set("ab");
-    a.set("abc");
-    a.set("abcd");
-#endif
-}
-
-#endif
-