2009-01-30  Darin Adler  <darin@apple.com>

        Reviewed by NOBODY (OOPS!).

        Bug 23622: create CFString and NSString objects from WebCore::String without copying the characters

        https://bugs.webkit.org/show_bug.cgi?id=23622

        * platform/text/cf/StringImplCF.cpp:

        (WebCore::StringWrapperCFAllocator::allocator): Added. Returns the allocator.

        (WebCore::StringWrapperCFAllocator::retain): Added. Callback for allocator.

        (WebCore::StringWrapperCFAllocator::release): Ditto.

        (WebCore::StringWrapperCFAllocator::copyDescription): Ditto.

        (WebCore::StringWrapperCFAllocator::allocate): Ditto.

        (WebCore::StringWrapperCFAllocator::reallocate): Ditto.

        (WebCore::StringWrapperCFAllocator::deallocate): Ditto.

        (WebCore::StringWrapperCFAllocator::preferredSize): Ditto.

        (WebCore::StringWrapperCFAllocator::create): Added. Creates the allocator, but

        returns 0 if garbage collection is enabled.

        (WebCore::StringImpl::createCFString): Use StringWrapperCFAllocator if possible.

        * platform/text/mac/StringImplMac.mm:

        (WebCore::StringImpl::operator NSString *): Use CFString and toll-free bridging,

        rather than using NSString directly. This lets NSString benefit from the above.

#include <wtf/PassRefPtr.h>

#if PLATFORM(MAC) || !defined(BUILDING_ON_TIGER)

#include <objc/objc-auto.h>

#endif

namespace StringWrapperCFAllocator {

    static CFAllocatorRef create();

    static StringImpl* currentString;

    static CFAllocatorRef allocator()

    {

        static CFAllocatorRef allocator = create();

        return allocator;

    }

    static const void* retain(const void* info)

    {

        return info;

    }

    static void release(const void*)

    {

        ASSERT_NOT_REACHED();

    }

    static CFStringRef copyDescription(const void*)

    {

        return CFSTR("WebCore::String-based allocator");

    }

    static void* allocate(CFIndex size, CFOptionFlags, void*)

    {

        StringImpl** header = static_cast<StringImpl**>(fastMalloc(sizeof(StringImpl*) + size));

        if (currentString)

            currentString->ref(); // Balanced by call to deref in StringWrapperCFAllocator::deallocate.

        *header = currentString;

        currentString = 0;

        return header + 1;

    }

    static void* reallocate(void* pointer, CFIndex newSize, CFOptionFlags, void*)

    {

        StringImpl** header = static_cast<StringImpl**>(pointer) - 1;

        header = static_cast<StringImpl**>(fastRealloc(header, sizeof(StringImpl*) + newSize));

        return header + 1;

    }

    static void deallocate(void* pointer, void*)

    {

        StringImpl** header = static_cast<StringImpl**>(pointer) - 1;

        if (StringImpl* string = *header)

            string->deref(); // Balanced by call to ref in StringWrapperCFAllocator::allocate.

        fastFree(header);

    }

    CFIndex preferredSize(CFIndex size, CFOptionFlags, void*)

    {

        // FIXME: If FastMalloc provided a "good size" callback, we'd want to use it here.

        // Note that this optimization would help performance for strings created with the

        // allocator that are mutable, and those typically are only created by callers who

        // make a new string using the old string's allocator, such as some of the call

        // sites in CFURL.

        return size;

    }

    static CFAllocatorRef create()

    {

#if PLATFORM(MAC) || !defined(BUILDING_ON_TIGER)

        if (objc_collectingEnabled())

            return 0;

#endif

        CFAllocatorContext context = { 0, 0, retain, release, copyDescription, allocate, reallocate, deallocate, preferredSize };

        return CFAllocatorCreate(0, &context);

    }

}

// On StringImpl creation we could check if the allocator is the StringWrapperCFAllocator.

// If it is, then we could find the original StringImpl and just return that. But to

// do that we'd have to compute the offset from CFStringRef to the allocated block;

// the CFStringRef is *not* at the start of an allocated block. Testing shows 1000x

// more calls to createCFString than calls to the create functions with the appropriate

// allocator, so it's probably not urgent optimize that case.