Source/WebKit2/Shared/mac/ArgumentCodersMac.mm

/*
 * Copyright (C) 2011 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#import "config.h"
#import "ArgumentCodersMac.h"

#import <CoreText/CoreText.h>
#if PLATFORM(IOS)
#import <UIKit/UIKit.h>
#endif

#import "ArgumentCodersCF.h"
#import "Decoder.h"
#import "Encoder.h"
#import "WebCoreArgumentCoders.h"
#import <WebCore/ColorMac.h>

using namespace WebCore;

namespace IPC {

enum class NSType {
    AttributedString,
#if USE(APPKIT)
    Color,
#endif
    Dictionary,
    Array,
#if USE(APPKIT)
    Font,
#endif
    Number,
    String,
    Date,
    Data,
    URL,
    Unknown,
};

}

namespace IPC {
static NSType typeFromObject(id object)
{
    ASSERT(object);

    if ([object isKindOfClass:[NSAttributedString class]])
        return NSType::AttributedString;
#if USE(APPKIT)
    if ([object isKindOfClass:[NSColor class]])
        return NSType::Color;
#endif
    if ([object isKindOfClass:[NSDictionary class]])
        return NSType::Dictionary;
#if USE(APPKIT)
    if ([object isKindOfClass:[NSFont class]])
        return NSType::Font;
#endif
    if ([object isKindOfClass:[NSNumber class]])
        return NSType::Number;
    if ([object isKindOfClass:[NSString class]])
        return NSType::String;
    if ([object isKindOfClass:[NSArray class]])
        return NSType::Array;
    if ([object isKindOfClass:[NSDate class]])
        return NSType::Date;
    if ([object isKindOfClass:[NSData class]])
        return NSType::Data;
    if ([object isKindOfClass:[NSURL class]])
        return NSType::URL;

    ASSERT_NOT_REACHED();
    return NSType::Unknown;
}

void encode(Encoder& encoder, id object)
{
    NSType type = typeFromObject(object);
    encoder << type;

    switch (type) {
    case NSType::AttributedString:
        encode(encoder, static_cast<NSAttributedString *>(object));
        return;
#if USE(APPKIT)
    case NSType::Color:
        encode(encoder, static_cast<NSColor *>(object));
        return;
#endif
    case NSType::Dictionary:
        encode(encoder, static_cast<NSDictionary *>(object));
        return;
#if USE(APPKIT)
    case NSType::Font:
        encode(encoder, static_cast<NSFont *>(object));
        return;
#endif
    case NSType::Number:
        encode(encoder, static_cast<NSNumber *>(object));
        return;
    case NSType::String:
        encode(encoder, static_cast<NSString *>(object));
        return;
    case NSType::Array:
        encode(encoder, static_cast<NSArray *>(object));
        return;
    case NSType::Date:
        encode(encoder, static_cast<NSDate *>(object));
        return;
    case NSType::Data:
        encode(encoder, static_cast<NSData *>(object));
        return;
    case NSType::URL:
        encode(encoder, static_cast<NSURL *>(object));
        return;
    case NSType::Unknown:
        break;
    }

    ASSERT_NOT_REACHED();
}

bool decode(Decoder& decoder, RetainPtr<id>& result)
{
    NSType type;
    if (!decoder.decodeEnum(type))
        return false;

    switch (type) {
    case NSType::AttributedString: {
        RetainPtr<NSAttributedString> string;
        if (!decode(decoder, string))
            return false;
        result = string;
        return true;
    }
#if USE(APPKIT)
    case NSType::Color: {
        RetainPtr<NSColor> color;
        if (!decode(decoder, color))
            return false;
        result = color;
        return true;
    }
#endif
    case NSType::Dictionary: {
        RetainPtr<NSDictionary> dictionary;
        if (!decode(decoder, dictionary))
            return false;
        result = dictionary;
        return true;
    }
#if USE(APPKIT)
    case NSType::Font: {
        RetainPtr<NSFont> font;
        if (!decode(decoder, font))
            return false;
        result = font;
        return true;
    }
#endif
    case NSType::Number: {
        RetainPtr<NSNumber> number;
        if (!decode(decoder, number))
            return false;
        result = number;
        return true;
    }
    case NSType::String: {
        RetainPtr<NSString> string;
        if (!decode(decoder, string))
            return false;
        result = string;
        return true;
    }
    case NSType::Array: {
        RetainPtr<NSArray> array;
        if (!decode(decoder, array))
            return false;
        result = array;
        return true;
    }
    case NSType::Date: {
        RetainPtr<NSDate> date;
        if (!decode(decoder, date))
            return false;
        result = date;
        return true;
    }
    case NSType::Data: {
        RetainPtr<NSData> data;
        if (!decode(decoder, data))
            return false;
        result = data;
        return true;
    }
    case NSType::URL: {
        RetainPtr<NSURL> URL;
        if (!decode(decoder, URL))
            return false;
        result = URL;
        return true;
    }
    case NSType::Unknown:
        ASSERT_NOT_REACHED();
        return false;
    }

    return false;
}

static inline bool isSerializableFont(CTFontRef font)
{
    return adoptCF(CTFontCopyAttribute(font, kCTFontURLAttribute));
}

static inline bool isSerializableValue(id value)
{
#if USE(APPKIT)
    auto fontClass = [NSFont class];
#else
    auto fontClass = [UIFont class];
#endif
    return ![value isKindOfClass:fontClass] || isSerializableFont(reinterpret_cast<CTFontRef>(value));
}

static inline RetainPtr<NSDictionary> filterUnserializableValues(NSDictionary *dictionary)
{
    __block bool modificationNecessary = false;
    [dictionary enumerateKeysAndObjectsUsingBlock:^(id key, id object, BOOL *stop) {
        if (!isSerializableValue(object)) {
            modificationNecessary = true;
            *stop = YES;
        }
    }];
    if (!modificationNecessary)
        return dictionary;

    auto result = adoptNS([[NSMutableDictionary alloc] init]);
    [dictionary enumerateKeysAndObjectsUsingBlock:^(id key, id object, BOOL *stop) {
        if (isSerializableValue(object))
            [result setObject:object forKey:key];
    }];
    return result;
}

void encode(Encoder& encoder, NSAttributedString *string)
{
    // Even though NSAttributedString is toll free bridged with CFAttributedStringRef, attributes' values may be not, so we should stay within this file's code.

    NSString *plainString = [string string];
    NSUInteger length = [plainString length];
    IPC::encode(encoder, plainString);

    Vector<std::pair<NSRange, RetainPtr<NSDictionary>>> ranges;

    NSUInteger position = 0;
    while (position < length) {
        // Collect ranges in a vector, becasue the total count should be encoded first.
        NSRange effectiveRange;
        RetainPtr<NSDictionary> attributesAtIndex = [string attributesAtIndex:position effectiveRange:&effectiveRange];
        ASSERT(effectiveRange.location == position);
        ASSERT(effectiveRange.length);
        ASSERT(NSMaxRange(effectiveRange) <= length);

        ranges.append(std::make_pair(effectiveRange, filterUnserializableValues(attributesAtIndex.get())));

        position = NSMaxRange(effectiveRange);
    }

    encoder << static_cast<uint64_t>(ranges.size());

    for (size_t i = 0; i < ranges.size(); ++i) {
        encoder << static_cast<uint64_t>(ranges[i].first.location);
        encoder << static_cast<uint64_t>(ranges[i].first.length);
        IPC::encode(encoder, ranges[i].second.get());
    }
}

bool decode(Decoder& decoder, RetainPtr<NSAttributedString>& result)
{
    RetainPtr<NSString> plainString;
    if (!IPC::decode(decoder, plainString))
        return false;

    NSUInteger stringLength = [plainString length];

    RetainPtr<NSMutableAttributedString> resultString = adoptNS([[NSMutableAttributedString alloc] initWithString:plainString.get()]);

    uint64_t rangeCount;
    if (!decoder.decode(rangeCount))
        return false;

    while (rangeCount--) {
        uint64_t rangeLocation;
        uint64_t rangeLength;
        RetainPtr<NSDictionary> attributes;
        if (!decoder.decode(rangeLocation))
            return false;
        if (!decoder.decode(rangeLength))
            return false;

        ASSERT(rangeLocation + rangeLength > rangeLocation);
        ASSERT(rangeLocation + rangeLength <= stringLength);
        if (rangeLocation + rangeLength <= rangeLocation || rangeLocation + rangeLength > stringLength)
            return false;

        if (!IPC::decode(decoder, attributes))
            return false;
        [resultString addAttributes:attributes.get() range:NSMakeRange(rangeLocation, rangeLength)];
    }

    result = adoptNS(resultString.leakRef());
    return true;
}

#if USE(APPKIT)
void encode(Encoder& encoder, NSColor *color)
{
    encoder << colorFromNSColor(color);
}

bool decode(Decoder& decoder, RetainPtr<NSColor>& result)
{
    Color color;
    if (!decoder.decode(color))
        return false;

    result = nsColor(color);
    return true;
}
#endif

void encode(Encoder& encoder, NSDictionary *dictionary)
{
    // Even though NSDictionary is toll free bridged with CFDictionaryRef, values may be not, so we should stay within this file's code.

    NSUInteger size = [dictionary count];
    NSArray *keys = [dictionary allKeys];
    NSArray *values = [dictionary allValues];

    encoder << static_cast<uint64_t>(size);

    for (NSUInteger i = 0; i < size; ++i) {
        id key = [keys objectAtIndex:i];
        id value = [values objectAtIndex:i];
        ASSERT(key);
        ASSERT([key isKindOfClass:[NSString class]]);
        ASSERT(value);
        ASSERT(isSerializableValue(value));

        // Ignore values we don't recognize.
        if (typeFromObject(value) == NSType::Unknown)
            continue;

        encode(encoder, (NSString *)key);
        encode(encoder, value);
    }
}

bool decode(Decoder& decoder, RetainPtr<NSDictionary>& result)
{
    uint64_t size;
    if (!decoder.decode(size))
        return false;

    RetainPtr<NSMutableDictionary> dictionary = adoptNS([[NSMutableDictionary alloc] initWithCapacity:size]);
    for (uint64_t i = 0; i < size; ++i) {
        // Try to decode the key name.
        RetainPtr<NSString> key;
        if (!decode(decoder, key))
            return false;

        RetainPtr<id> value;
        if (!decode(decoder, value))
            return false;

        [dictionary setObject:value.get() forKey:key.get()];
    }

    result = adoptNS(dictionary.leakRef());
    return true;
}

#if USE(APPKIT)
void encode(Encoder& encoder, NSFont *font)
{
    // NSFont could use CTFontRef code if we had it in ArgumentCodersCF.
    encode(encoder, [[font fontDescriptor] fontAttributes]);
}

bool decode(Decoder& decoder, RetainPtr<NSFont>& result)
{
    RetainPtr<NSDictionary> fontAttributes;
    if (!decode(decoder, fontAttributes))
        return false;

    NSFontDescriptor *fontDescriptor = [NSFontDescriptor fontDescriptorWithFontAttributes:fontAttributes.get()];
    result = [NSFont fontWithDescriptor:fontDescriptor size:0];

    return result;
}
#endif

void encode(Encoder& encoder, NSNumber *number)
{
    encode(encoder, (CFNumberRef)number);
}

bool decode(Decoder& decoder, RetainPtr<NSNumber>& result)
{
    RetainPtr<CFNumberRef> number;
    if (!decode(decoder, number))
        return false;

    result = adoptNS((NSNumber *)number.leakRef());
    return true;
}

void encode(Encoder& encoder, NSString *string)
{
    encode(encoder, (CFStringRef)string);
}

bool decode(Decoder& decoder, RetainPtr<NSString>& result)
{
    RetainPtr<CFStringRef> string;
    if (!decode(decoder, string))
        return false;

    result = adoptNS((NSString *)string.leakRef());
    return true;
}

void encode(Encoder& encoder, NSArray *array)
{
    NSUInteger size = [array count];
    encoder << static_cast<uint64_t>(size);

    for (NSUInteger i = 0; i < size; ++i) {
        id value = [array objectAtIndex:i];

        // Ignore values we don't recognize.
        if (typeFromObject(value) == NSType::Unknown)
            continue;

        ASSERT(isSerializableValue(value));

        encode(encoder, value);
    }
}

bool decode(Decoder& decoder, RetainPtr<NSArray>& result)
{
    uint64_t size;
    if (!decoder.decode(size))
        return false;

    RetainPtr<NSMutableArray> array = adoptNS([[NSMutableArray alloc] initWithCapacity:size]);
    for (uint64_t i = 0; i < size; ++i) {
        RetainPtr<id> value;
        if (!decode(decoder, value))
            return false;

        [array addObject:value.get()];
    }

    result = adoptNS(array.leakRef());
    return true;
}

void encode(Encoder& encoder, NSDate *date)
{
    encode(encoder, (CFDateRef)date);
}

bool decode(Decoder& decoder, RetainPtr<NSDate>& result)
{
    RetainPtr<CFDateRef> date;
    if (!decode(decoder, date))
        return false;

    result = adoptNS((NSDate *)date.leakRef());
    return true;
}

void encode(Encoder& encoder, NSData *data)
{
    encode(encoder, (CFDataRef)data);
}

bool decode(Decoder& decoder, RetainPtr<NSData>& result)
{
    RetainPtr<CFDataRef> data;
    if (!decode(decoder, data))
        return false;

    result = adoptNS((NSData *)data.leakRef());
    return true;
}

void encode(Encoder& encoder, NSURL *URL)
{
    encode(encoder, (CFURLRef)URL);
}

bool decode(Decoder& decoder, RetainPtr<NSURL>& result)
{
    RetainPtr<CFURLRef> URL;
    if (!decode(decoder, URL))
        return false;

    result = adoptNS((NSURL *)URL.leakRef());
    return true;
}

} // namespace IPC

namespace WTF {
template<> struct EnumTraits<IPC::NSType> {
    using values = EnumValues<
        IPC::NSType,
        IPC::NSType::AttributedString,
    #if USE(APPKIT)
        IPC::NSType::Color,
    #endif
        IPC::NSType::Dictionary,
        IPC::NSType::Array,
    #if USE(APPKIT)
        IPC::NSType::Font,
    #endif
        IPC::NSType::Number,
        IPC::NSType::String,
        IPC::NSType::Date,
        IPC::NSType::Data,
        IPC::NSType::URL,
        IPC::NSType::Unknown
    >;
};
}