2015-07-10  Gyuyoung Kim  <gyuyoung.kim@webkit.org>

        [EFL] Support indexeddb for WK2

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

        Reviewed by NOBODY (OOPS!).

        Add stub implementation for indexeddb. Move KeyedDecoder and KeyedEncoder from gtk to glib

        in order to share it between GTK and EFL ports.

        * DatabaseProcess/EntryPoint/unix/DatabaseProcessMain.cpp:

        * DatabaseProcess/efl/DatabaseProcessMainEfl.cpp: Copied from Source/WebKit2/DatabaseProcess/EntryPoint/unix/DatabaseProcessMain.cpp.

        (WebKit::DatabaseProcessMainUnix):

        * PlatformEfl.cmake:

        * PlatformGTK.cmake:

        * Shared/glib/KeyedDecoder.cpp: Renamed from Source/WebKit2/Shared/gtk/KeyedDecoder.cpp.

        (WebKit::KeyedDecoder::KeyedDecoder):

        (WebKit::KeyedDecoder::~KeyedDecoder):

        (WebKit::KeyedDecoder::dictionaryFromGVariant):

        (WebKit::KeyedDecoder::decodeBytes):

        (WebKit::KeyedDecoder::decodeSimpleValue):

        (WebKit::KeyedDecoder::decodeBool):

        (WebKit::KeyedDecoder::decodeUInt32):

        (WebKit::KeyedDecoder::decodeInt32):

        (WebKit::KeyedDecoder::decodeInt64):

        (WebKit::KeyedDecoder::decodeFloat):

        (WebKit::KeyedDecoder::decodeDouble):

        (WebKit::KeyedDecoder::decodeString):

        (WebKit::KeyedDecoder::beginObject):

        (WebKit::KeyedDecoder::endObject):

        (WebKit::KeyedDecoder::beginArray):

        (WebKit::KeyedDecoder::beginArrayElement):

        (WebKit::KeyedDecoder::endArrayElement):

        (WebKit::KeyedDecoder::endArray):

        * Shared/glib/KeyedDecoder.h: Renamed from Source/WebKit2/Shared/gtk/KeyedDecoder.h.

        * Shared/glib/KeyedEncoder.cpp: Renamed from Source/WebKit2/Shared/gtk/KeyedEncoder.cpp.

        (WebKit::KeyedEncoder::KeyedEncoder):

        (WebKit::KeyedEncoder::~KeyedEncoder):

        (WebKit::KeyedEncoder::encodeBytes):

        (WebKit::KeyedEncoder::encodeBool):

        (WebKit::KeyedEncoder::encodeUInt32):

        (WebKit::KeyedEncoder::encodeInt32):

        (WebKit::KeyedEncoder::encodeInt64):

        (WebKit::KeyedEncoder::encodeFloat):

        (WebKit::KeyedEncoder::encodeDouble):

        (WebKit::KeyedEncoder::encodeString):

        (WebKit::KeyedEncoder::beginObject):

        (WebKit::KeyedEncoder::endObject):

        (WebKit::KeyedEncoder::beginArray):

        (WebKit::KeyedEncoder::beginArrayElement):

        (WebKit::KeyedEncoder::endArrayElement):

        (WebKit::KeyedEncoder::endArray):

        (WebKit::KeyedEncoder::finishEncoding):

        * Shared/glib/KeyedEncoder.h: Renamed from Source/WebKit2/Shared/gtk/KeyedEncoder.h.

        * UIProcess/Databases/efl/DatabaseProcessProxyEfl.cpp: Copied from Source/WebKit2/DatabaseProcess/EntryPoint/unix/DatabaseProcessMain.cpp.

        (WebKit::DatabaseProcessProxy::platformGetLaunchOptions):

#include "config.h"

/*

 * Copyright (C) 2015 Naver Corp. 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.

 */

#include "config.h"

#include "DatabaseProcess.h"

#if ENABLE(DATABASE_PROCESS)

#include "ChildProcessMain.h"

#include "DatabaseProcessMainUnix.h"

using namespace WebCore;

namespace WebKit {

class DatabaseProcessMain final: public ChildProcessMainBase {

public:

    bool platformInitialize() override

    {

        return true;

    }

};

int DatabaseProcessMainUnix(int argc, char** argv)

{

    return ChildProcessMain<DatabaseProcess, DatabaseProcessMain>(argc, argv);

}

} // namespace WebKit

#endif // ENABLE(DATABASE_PROCESS)

    DatabaseProcess/efl/DatabaseProcessMainEfl.cpp

    Shared/glib/KeyedDecoder.cpp

    Shared/glib/KeyedEncoder.cpp

    UIProcess/Databases/efl/DatabaseProcessProxyEfl.cpp

    "${WEBKIT2_DIR}/DatabaseProcess/unix"

    "${WTF_DIR}"

    "${WEBKIT2_DIR}"

list(APPEND DatabaseProcess_SOURCES

    DatabaseProcess/EntryPoint/unix/DatabaseProcessMain.cpp

)

    Shared/glib/KeyedDecoder.cpp

    Shared/glib/KeyedEncoder.cpp

    "${WEBKIT2_DIR}/Shared/glib"

/*

 * Copyright (C) 2015 Igalia S.L.

 *

 * 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.

 */

#include "config.h"

#include "KeyedDecoder.h"

#include <wtf/text/CString.h>

namespace WebKit {

KeyedDecoder::KeyedDecoder(const uint8_t* data, size_t size)

{

    GRefPtr<GBytes> bytes = adoptGRef(g_bytes_new(data, size));

    GRefPtr<GVariant> variant = g_variant_new_from_bytes(G_VARIANT_TYPE("a{sv}"), bytes.get(), TRUE);

    m_dictionaryStack.append(dictionaryFromGVariant(variant.get()));

}

KeyedDecoder::~KeyedDecoder()

{

    ASSERT(m_dictionaryStack.size() == 1);

    ASSERT(m_arrayStack.isEmpty());

    ASSERT(m_arrayIndexStack.isEmpty());

}

HashMap<String, GRefPtr<GVariant>> KeyedDecoder::dictionaryFromGVariant(GVariant* variant)

{

    HashMap<String, GRefPtr<GVariant>> dictionary;

    GVariantIter iter;

    g_variant_iter_init(&iter, variant);

    const char* key;

    GVariant* value;

    while (g_variant_iter_loop(&iter, "{&sv}", &key, &value))

        dictionary.set(String::fromUTF8(key), value);

    return WTF::move(dictionary);

}

bool KeyedDecoder::decodeBytes(const String& key, const uint8_t*& bytes, size_t& size)

{

    GRefPtr<GVariant> value = m_dictionaryStack.last().get(key);

    if (!value)

        return false;

    size = g_variant_get_size(value.get());

    bytes = static_cast<const uint8_t*>(g_variant_get_data(value.get()));

    return true;

}

template<typename T, typename F>

bool KeyedDecoder::decodeSimpleValue(const String& key, T& result, F getFunction)

{

    GRefPtr<GVariant> value = m_dictionaryStack.last().get(key);

    if (!value)

        return false;

    result = getFunction(value.get());

    return true;

}

bool KeyedDecoder::decodeBool(const String& key, bool& result)

{

    return decodeSimpleValue(key, result, g_variant_get_boolean);

}

bool KeyedDecoder::decodeUInt32(const String& key, uint32_t& result)

{

    return decodeSimpleValue(key, result, g_variant_get_uint32);

}

bool KeyedDecoder::decodeInt32(const String& key, int32_t& result)

{

    return decodeSimpleValue(key, result, g_variant_get_int32);

}

bool KeyedDecoder::decodeInt64(const String& key, int64_t& result)

{

    return decodeSimpleValue(key, result, g_variant_get_int64);

}

bool KeyedDecoder::decodeFloat(const String& key, float& result)

{

    return decodeSimpleValue(key, result, g_variant_get_double);

}

bool KeyedDecoder::decodeDouble(const String& key, double& result)

{

    return decodeSimpleValue(key, result, g_variant_get_double);

}

bool KeyedDecoder::decodeString(const String& key, String& result)

{

    GRefPtr<GVariant> value = m_dictionaryStack.last().get(key);

    if (!value)

        return false;

    result = String::fromUTF8(g_variant_get_string(value.get(), nullptr));

    return true;

}

bool KeyedDecoder::beginObject(const String& key)

{

    GRefPtr<GVariant> value = m_dictionaryStack.last().get(key);

    if (!value)

        return false;

    m_dictionaryStack.append(dictionaryFromGVariant(value.get()));

    return true;

}

void KeyedDecoder::endObject()

{

    m_dictionaryStack.removeLast();

}

bool KeyedDecoder::beginArray(const String& key)

{

    GRefPtr<GVariant> value = m_dictionaryStack.last().get(key);

    if (!value)

        return false;

    m_arrayStack.append(value.get());

    m_arrayIndexStack.append(0);

    return true;

}

bool KeyedDecoder::beginArrayElement()

{

    if (m_arrayIndexStack.last() >= g_variant_n_children(m_arrayStack.last()))

        return false;

    GRefPtr<GVariant> variant = adoptGRef(g_variant_get_child_value(m_arrayStack.last(), m_arrayIndexStack.last()++));

    m_dictionaryStack.append(dictionaryFromGVariant(variant.get()));

    return true;

}

void KeyedDecoder::endArrayElement()

{

    m_dictionaryStack.removeLast();

}

void KeyedDecoder::endArray()

{

    m_arrayStack.removeLast();

    m_arrayIndexStack.removeLast();

}

} // namespace WebKit

/*

 * Copyright (C) 2015 Igaia S.L.

 *

 * 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.

 */

#ifndef KeyedDecoder_h

#define KeyedDecoder_h

#include <WebCore/KeyedCoding.h>

#include <glib.h>

#include <wtf/HashMap.h>

#include <wtf/glib/GRefPtr.h>

#include <wtf/text/StringHash.h>

#include <wtf/text/WTFString.h>

namespace WebKit {

class KeyedDecoder final : public WebCore::KeyedDecoder {

public:

    KeyedDecoder(const uint8_t* data, size_t);

    virtual ~KeyedDecoder() override;

private:

    virtual bool decodeBytes(const String& key, const uint8_t*&, size_t&) override;

    virtual bool decodeBool(const String& key, bool&) override;

    virtual bool decodeUInt32(const String& key, uint32_t&) override;

    virtual bool decodeInt32(const String& key, int32_t&) override;

    virtual bool decodeInt64(const String& key, int64_t&) override;

    virtual bool decodeFloat(const String& key, float&) override;

    virtual bool decodeDouble(const String& key, double&) override;

    virtual bool decodeString(const String& key, String&) override;

    virtual bool beginObject(const String& key) override;

    virtual void endObject() override;

    virtual bool beginArray(const String& key) override;

    virtual bool beginArrayElement() override;

    virtual void endArrayElement() override;

    virtual void endArray() override;

    template<typename T, typename F> bool decodeSimpleValue(const String& key, T& result, F getFunction);

    HashMap<String, GRefPtr<GVariant>> dictionaryFromGVariant(GVariant*);

    Vector<HashMap<String, GRefPtr<GVariant>>> m_dictionaryStack;

    Vector<GVariant*, 16> m_arrayStack;

    Vector<unsigned> m_arrayIndexStack;

};

} // namespace WebKit

#endif // KeyedDecoder_h

/*

 * Copyright (C) 2015 Igalia S.L.

 *

 * 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.

 */

#include "config.h"

#include "KeyedEncoder.h"

#include <WebCore/SharedBuffer.h>

#include <wtf/text/CString.h>

using namespace WebCore;

namespace WebKit {

KeyedEncoder::KeyedEncoder()

{

    g_variant_builder_init(&m_variantBuilder, G_VARIANT_TYPE("a{sv}"));

    m_variantBuilderStack.append(&m_variantBuilder);

}

KeyedEncoder::~KeyedEncoder()

{

    ASSERT(m_variantBuilderStack.size() == 1);

    ASSERT(m_variantBuilderStack.last() == &m_variantBuilder);

    ASSERT(m_arrayStack.isEmpty());

    ASSERT(m_objectStack.isEmpty());

}

void KeyedEncoder::encodeBytes(const String& key, const uint8_t* bytes, size_t size)

{

    GRefPtr<GBytes> gBytes = adoptGRef(g_bytes_new_static(bytes, size));

    g_variant_builder_add(m_variantBuilderStack.last(), "{sv}", key.utf8().data(), g_variant_new_from_bytes(G_VARIANT_TYPE("ay"), gBytes.get(), TRUE));

}

void KeyedEncoder::encodeBool(const String& key, bool value)

{

    g_variant_builder_add(m_variantBuilderStack.last(), "{sv}", key.utf8().data(), g_variant_new_boolean(value));

}

void KeyedEncoder::encodeUInt32(const String& key, uint32_t value)

{

    g_variant_builder_add(m_variantBuilderStack.last(), "{sv}", key.utf8().data(), g_variant_new_uint32(value));

}

void KeyedEncoder::encodeInt32(const String& key, int32_t value)

{

    g_variant_builder_add(m_variantBuilderStack.last(), "{sv}", key.utf8().data(), g_variant_new_int32(value));

}

void KeyedEncoder::encodeInt64(const String& key, int64_t value)

{

    g_variant_builder_add(m_variantBuilderStack.last(), "{sv}", key.utf8().data(), g_variant_new_int64(value));

}

void KeyedEncoder::encodeFloat(const String& key, float value)

{

    encodeDouble(key, value);

}

void KeyedEncoder::encodeDouble(const String& key, double value)

{

    g_variant_builder_add(m_variantBuilderStack.last(), "{sv}", key.utf8().data(), g_variant_new_double(value));

}

void KeyedEncoder::encodeString(const String& key, const String& value)

{

    g_variant_builder_add(m_variantBuilderStack.last(), "{sv}", key.utf8().data(), g_variant_new_string(value.utf8().data()));

}

void KeyedEncoder::beginObject(const String& key)

{

    GRefPtr<GVariantBuilder> builder = adoptGRef(g_variant_builder_new(G_VARIANT_TYPE("aa{sv}")));

    m_objectStack.append(std::make_pair(key, builder));

    m_variantBuilderStack.append(builder.get());

}

void KeyedEncoder::endObject()

{

    GVariantBuilder* builder = m_variantBuilderStack.takeLast();

    g_variant_builder_add(m_variantBuilderStack.last(), "{sv}", m_objectStack.last().first.utf8().data(), g_variant_builder_end(builder));

    m_objectStack.removeLast();

}

void KeyedEncoder::beginArray(const String& key)

{

    m_arrayStack.append(std::make_pair(key, adoptGRef(g_variant_builder_new(G_VARIANT_TYPE("aa{sv}")))));

}

void KeyedEncoder::beginArrayElement()

{

    m_variantBuilderStack.append(g_variant_builder_new(G_VARIANT_TYPE("a{sv}")));

}

void KeyedEncoder::endArrayElement()

{

    GRefPtr<GVariantBuilder> variantBuilder = adoptGRef(m_variantBuilderStack.takeLast());

    g_variant_builder_add_value(m_arrayStack.last().second.get(), g_variant_builder_end(variantBuilder.get()));

}

void KeyedEncoder::endArray()

{

    g_variant_builder_add(m_variantBuilderStack.last(), "{sv}", m_arrayStack.last().first.utf8().data(), g_variant_builder_end(m_arrayStack.last().second.get()));

    m_arrayStack.removeLast();

}

PassRefPtr<SharedBuffer> KeyedEncoder::finishEncoding()

{

    g_assert(m_variantBuilderStack.last() == &m_variantBuilder);

    GRefPtr<GVariant> variant = g_variant_builder_end(&m_variantBuilder);

    GRefPtr<GBytes> data = g_variant_get_data_as_bytes(variant.get());

    return SharedBuffer::create(static_cast<const unsigned char*>(g_bytes_get_data(data.get(), nullptr)), static_cast<unsigned>(g_bytes_get_size(data.get())));

}

} // namespace WebKit

/*

 * Copyright (C) 2015 Igalia S.L.

 *

 * 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.

 */

#ifndef KeyedEncoder_h

#define KeyedEncoder_h

#include <WebCore/KeyedCoding.h>

#include <glib.h>

#include <wtf/Vector.h>

#include <wtf/glib/GRefPtr.h>

#include <wtf/text/WTFString.h>

namespace WebKit {

class KeyedEncoder final : public WebCore::KeyedEncoder {

public:

    KeyedEncoder();

    ~KeyedEncoder();

    virtual PassRefPtr<WebCore::SharedBuffer> finishEncoding() override;

private:

    virtual void encodeBytes(const String& key, const uint8_t*, size_t) override;

    virtual void encodeBool(const String& key, bool) override;

    virtual void encodeUInt32(const String& key, uint32_t) override;

    virtual void encodeInt32(const String& key, int32_t) override;

    virtual void encodeInt64(const String& key, int64_t) override;

    virtual void encodeFloat(const String& key, float) override;

    virtual void encodeDouble(const String& key, double) override;

    virtual void encodeString(const String& key, const String&) override;

    virtual void beginObject(const String& key) override;

    virtual void endObject() override;

    virtual void beginArray(const String& key) override;

    virtual void beginArrayElement() override;

    virtual void endArrayElement() override;

    virtual void endArray() override;

    GVariantBuilder m_variantBuilder;

    Vector<GVariantBuilder*, 16> m_variantBuilderStack;

    Vector<std::pair<String, GRefPtr<GVariantBuilder>>, 16> m_arrayStack;

    Vector<std::pair<String, GRefPtr<GVariantBuilder>>, 16> m_objectStack;

};

} // namespace WebKit

#endif // KeyedEncoder_h

/*

 * Copyright (C) 2015 Naver Corp. 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.

 */

#include "config.h"

#include "DatabaseProcessProxy.h"

#if ENABLE(DATABASE_PROCESS)

namespace WebKit {

void DatabaseProcessProxy::platformGetLaunchOptions(ProcessLauncher::LaunchOptions&)

{

}

} // namespace WebKit

#endif // ENABLE(DATABASE_PROCESS)