2014-10-28  Adrian Perez de Castro  <aperez@igalia.com>

        [GTK] Support script message handlers WebKitUserContentManager

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

        Reviewed by NOBODY (OOPS!).

        Support user script message handlers in WebKitUserContentManager.

        This needs building with ENABLE_USER_MESSAGE_HANDLERS, for which

        an option is added to the CMake build files. The option is disabled

        globally by default, and the WebKitGTK port enables it. On the API

        level, two new methods to register and unregister names are provided

        in the "window.webkit" namespace, and on message reception the

        "WebKitUserContentManager::script-message-received" signal is

        emitted, using the registered names as signal detail.

        * CMakeLists.txt: Conditionally add the needed files to the build

        when the ENABLE_USER_MESSAGE_HANDLERS feature is enabled.

2014-10-28  Adrian Perez de Castro  <aperez@igalia.com>

        [GTK] Support script message handlers WebKitUserContentManager

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

        Reviewed by NOBODY (OOPS!).

        Support user script message handlers in WebKitUserContentManager.

        This needs building with ENABLE_USER_MESSAGE_HANDLERS, for which

        an option is added to the CMake build files. The option is disabled

        globally by default, and the WebKitGTK port enables it. On the API

        level, two new methods to register and unregister names are provided

        in the "window.webkit" namespace, and on message reception the

        "WebKitUserContentManager::script-message-received" signal is

        emitted, using the registered names as signal detail.

        * UIProcess/API/gtk/WebKitJavascriptResult.cpp: Add a new private

        function to construct a WebKitJavascriptResult directly from a

        WebCore::SerializedScriptValue.

        (_WebKitJavascriptResult::_WebKitJavascriptResult): Ditto.

        (webkitJavascriptResultCreate): Ditto.

        * UIProcess/API/gtk/WebKitJavascriptResultPrivate.h: Ditto.

        * UIProcess/API/gtk/WebKitUserContentManager.cpp:

        (webkit_user_content_manager_class_init): Install the

        "script-message-received" signal.

        (webkit_user_content_manager_register_script_message_handler):

        Added.

        (webkit_user_content_manager_unregister_script_message_handler):

        Added.

        * UIProcess/API/gtk/WebKitUserContentManager.h: Added the new

        public API methods.

        * UIProcess/API/gtk/docs/webkit2gtk-sections.txt: Ditto.

        * UIProcess/API/gtk/docs/webkit2gtk.types: Add

        webkit_user_content_manager_get_type() to the list in order to make

        gtk-doc to generate documentation for signals.

if (ENABLE_USER_MESSAGE_HANDLERS)

    list(APPEND WebCore_IDL_FILES

        page/UserMessageHandler.idl

        page/UserMessageHandlersNamespace.idl

        page/WebKitNamespace.idl

    )

    list(APPEND WebCore_SOURCES

        bindings/js/JSUserMessageHandlersNamespaceCustom.cpp

        page/UserMessageHandler.cpp

        page/UserMessageHandlerDescriptor.cpp

        page/UserMessageHandlersNamespace.cpp

        page/WebKitNamespace.cpp

    )

endif ()

#include <WebCore/SerializedScriptValue.h>

#include "WebKitJavascriptResultPrivate.h"

#include "WebKitWebContextPrivate.h"

#include "WebScriptMessageHandler.h"

#include "WebSerializedScriptValue.h"

    GObjectClass* gObjectClass = G_OBJECT_CLASS(klass);

    /**

     * WebKitUserContentManager::script-message-received:

     * @manager: the #WebKitUserContentManager

     * @js_result: the #WebKitJavascriptResult holding the value received from the JavaScript world.

     *

     * This signal is emitted when JavaScript in a web view calls

     * <code>window.webkit.messageHandlers.&lt;name&gt;.postMessage()</code>, after registering

     * <code>&lt;name&gt;</code> using

     * webkit_user_content_manager_register_script_message_handler()

     *

     * Since: 2.8

     */

    signals[SCRIPT_MESSAGE_RECEIVED] =

        g_signal_new(

            "script-message-received",

            G_TYPE_FROM_CLASS(gObjectClass),

            static_cast<GSignalFlags>(G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED),

            0, nullptr, nullptr,

            g_cclosure_marshal_VOID__BOXED,

            G_TYPE_NONE, 1,

            WEBKIT_TYPE_JAVASCRIPT_RESULT);

class ScriptMessageClientGtk final : public WebScriptMessageHandler::Client {

public:

    ScriptMessageClientGtk(WebKitUserContentManager* manager, const char* handlerName)

        : m_handlerName(g_quark_from_string(handlerName))

        , m_manager(manager)

    {

    }

    virtual void didPostMessage(WebPageProxy& page, WebFrameProxy&, WebCore::SerializedScriptValue& serializedScriptValue)

    {

        WebKitJavascriptResult* jsResult = webkitJavascriptResultCreate(WEBKIT_WEB_VIEW(page.viewWidget()), serializedScriptValue);

        g_signal_emit(m_manager, signals[SCRIPT_MESSAGE_RECEIVED], m_handlerName, jsResult);

        webkit_javascript_result_unref(jsResult);

    }

    virtual ~ScriptMessageClientGtk() { }

private:

    GQuark m_handlerName;

    WebKitUserContentManager* m_manager;

};

/**

 * webkit_user_content_manager_register_script_message_handler:

 * @manager: A #WebKitUserContentManager

 * @name: Name of the script message channel

 *

 * Registers a new user script message handler. After it is registered,

 * scripts can use `window.webkit.messageHandlers.<name>.postMessage(value)`

 * to send messages. Those messages are received by connecting handlers

 * to the #WebKitUserContentManager::script-message-received signal. The

 * handler name is used as the detail of the signal. To avoid race

 * conditions between registering the handler name, and starting to

 * receive the signals, it is recommended to connect to the signal

 * *before* registering the handler name:

 *

 * <informalexample><programlisting>

 * WebKitWebView *view = webkit_web_view_new ();

 * WebKitUserContentManager *manager = webkit_web_view_get_user_content_manager ();

 * g_signal_connect (manager, "script-message-received::foobar",

 *                   G_CALLBACK (handle_script_message), NULL);

 * webkit_user_content_manager_register_script_message_handler (manager, "foobar");

 * </programlisting></informalexample>

 *

 * Registering a script message handler will fail if the requested

 * name has been already registered before.

 *

 * Returns: %TRUE if message handler was registered successfully, or %FALSE otherwise.

 *

 * Since: 2.8

 */

gboolean webkit_user_content_manager_register_script_message_handler(WebKitUserContentManager* manager, const char* name)

{

    g_return_val_if_fail(WEBKIT_IS_USER_CONTENT_MANAGER(manager), FALSE);

    g_return_val_if_fail(name, FALSE);

    RefPtr<WebScriptMessageHandler> handler =

        WebScriptMessageHandler::create(std::make_unique<ScriptMessageClientGtk>(manager, name), String::fromUTF8(name));

    return manager->priv->userContentController->addUserScriptMessageHandler(handler.get());

}

/**

 * webkit_user_content_manager_unregister_script_message_handler:

 * @manager: A #WebKitUserContentManager

 * @name: Name of the script message channel

 *

 * Unregisters a previously registered message handler.

 *

 * Note that this does *not* disconnect handlers for the

 * #WebKitUserContentManager::script-message-received signal,

 * they will be kept connected, but the signal will not be emitted

 * unless the handler name is registered again.

 *

 * See also webkit_user_content_manager_register_script_message_handler()

 *

 * Since: 2.8

 */

void webkit_user_content_manager_unregister_script_message_handler(WebKitUserContentManager* manager, const char* name)

{

    g_return_if_fail(WEBKIT_IS_USER_CONTENT_MANAGER(manager));

    g_return_if_fail(name);

    manager->priv->userContentController->removeUserMessageHandlerForName(String::fromUTF8(name));

}

#include "WebSerializedScriptValue.h"

webkit_user_content_manager_register_script_message_handler

webkit_user_content_manager_unregister_script_message_handler

webkit_user_content_manager_get_type

WEBKIT_OPTION_DEFAULT_PORT_VALUE(ENABLE_USER_MESSAGE_HANDLERS ON)

    WEBKIT_OPTION_DEFINE(ENABLE_USER_MESSAGE_HANDLERS "Toggle user script message handler support" OFF)

#cmakedefine01 ENABLE_USER_MESSAGE_HANDLERS

2014-10-28  Adrian Perez de Castro  <aperez@igalia.com>

        [GTK] Support script message handlers WebKitUserContentManager

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

        Reviewed by NOBODY (OOPS!).

        Support user script message handlers in WebKitUserContentManager.

        This needs building with ENABLE_USER_MESSAGE_HANDLERS, for which

        an option is added to the CMake build files. The option is disabled

        globally by default, and the WebKitGTK port enables it. On the API

        level, two new methods to register and unregister names are provided

        in the "window.webkit" namespace, and on message reception the

        "WebKitUserContentManager::script-message-received" signal is

        emitted, using the registered names as signal detail.

        * TestWebKitAPI/Tests/WebKit2Gtk/TestWebKitUserContentManager.cpp:

        Add test case for user script message handlers.

        (scriptMessageReceived):

        (testUserContentManagerScriptMessageReceived):

        (beforeAll):

#include <wtf/gobject/GUniquePtr.h>

class UserScriptMessageTest : public UserContentManagerTest {

public:

    MAKE_GLIB_TEST_FIXTURE(UserScriptMessageTest);

    UserScriptMessageTest()

        : UserContentManagerTest()

        , m_userScriptMessage(nullptr)

    {

    }

    ~UserScriptMessageTest()

    {

    }

    bool registerHandler(const char* handlerName)

    {

        return webkit_user_content_manager_register_script_message_handler(m_userContentManager.get(), handlerName);

    }

    void unregisterHandler(const char* handlerName)

    {

        webkit_user_content_manager_unregister_script_message_handler(m_userContentManager.get(), handlerName);

    }

    static void scriptMessageReceived(WebKitUserContentManager* userContentManager, WebKitJavascriptResult* jsResult, UserScriptMessageTest* test)

    {

        g_signal_handlers_disconnect_by_func(userContentManager, reinterpret_cast<gpointer>(scriptMessageReceived), test);

        g_main_loop_quit(test->m_mainLoop);

        g_assert(!test->m_userScriptMessage);

        test->m_userScriptMessage = webkit_javascript_result_ref(jsResult);

    }

    WebKitJavascriptResult* postMessageAndWaitUntilReceived(const char* handlerName, const char* javascriptValueAsText)

    {

        if (m_userScriptMessage) {

            webkit_javascript_result_unref(m_userScriptMessage);

            m_userScriptMessage = nullptr;

        }

        GUniquePtr<char> signalName(g_strdup_printf("script-message-received::%s", handlerName));

        g_signal_connect(m_userContentManager.get(), signalName.get(), G_CALLBACK(scriptMessageReceived), this);

        GUniquePtr<char> javascriptSnippet(g_strdup_printf("window.webkit.messageHandlers.%s.postMessage(%s);", handlerName, javascriptValueAsText));

        webkit_web_view_run_javascript(m_webView, javascriptSnippet.get(), nullptr, nullptr, nullptr);

        g_main_loop_run(m_mainLoop);

        g_assert(m_userScriptMessage);

        WebKitJavascriptResult* result = m_userScriptMessage;

        m_userScriptMessage = nullptr;

        return result;

    }

private:

    WebKitJavascriptResult* m_userScriptMessage;

};

static void testUserContentManagerScriptMessageReceived(UserScriptMessageTest* test, gconstpointer)

{

    g_assert(test->registerHandler("msg"));

    // Trying to register the same handler a second time must fail

    g_assert(!test->registerHandler("msg"));

    test->loadHtml("<html></html>", nullptr);

    test->waitUntilLoadFinished();

    // Check that the "window.webkit.messageHandlers" namespace exists

    GUniqueOutPtr<GError> error;

    WebKitJavascriptResult* javascriptResult = test->runJavaScriptAndWaitUntilFinished("window.webkit.messageHandlers ? 'y' : 'n';", &error.outPtr());

    g_assert(javascriptResult);

    g_assert(!error.get());

    GUniquePtr<char> valueString(WebViewTest::javascriptResultToCString(javascriptResult));

    g_assert_cmpstr(valueString.get(), ==, "y");

    // Check that the "document.webkit.messageHandlers.msg" namespace exists

    javascriptResult = test->runJavaScriptAndWaitUntilFinished("window.webkit.messageHandlers.msg ? 'y' : 'n';", &error.outPtr());

    g_assert(javascriptResult);

    g_assert(!error.get());

    valueString.reset(WebViewTest::javascriptResultToCString(javascriptResult));

    g_assert_cmpstr(valueString.get(), ==, "y");

    WebKitJavascriptResult* message = test->postMessageAndWaitUntilReceived("msg", "'user message'");

    valueString.reset(WebViewTest::javascriptResultToCString(message));

    webkit_javascript_result_unref(message);

    g_assert_cmpstr(valueString.get(), ==, "user message");

    // Messages should arrive despite of other handlers being registered

    g_assert(test->registerHandler("anotherHandler"));

    // Check that the "document.webkit.messageHandlers.msg" namespace still exists

    javascriptResult = test->runJavaScriptAndWaitUntilFinished("window.webkit.messageHandlers.msg ? 'y' : 'n';", &error.outPtr());

    g_assert(javascriptResult);

    g_assert(!error.get());

    valueString.reset(WebViewTest::javascriptResultToCString(javascriptResult));

    g_assert_cmpstr(valueString.get(), ==, "y");

    // Check that the "document.webkit.messageHandlers.anotherHandler" namespace exists

    javascriptResult = test->runJavaScriptAndWaitUntilFinished("window.webkit.messageHandlers.anotherHandler ? 'y' : 'n';", &error.outPtr());

    g_assert(javascriptResult);

    g_assert(!error.get());

    valueString.reset(WebViewTest::javascriptResultToCString(javascriptResult));

    g_assert_cmpstr(valueString.get(), ==, "y");

    message = test->postMessageAndWaitUntilReceived("msg", "'handler: msg'");

    valueString.reset(WebViewTest::javascriptResultToCString(message));

    webkit_javascript_result_unref(message);

    g_assert_cmpstr(valueString.get(), ==, "handler: msg");

    message = test->postMessageAndWaitUntilReceived("anotherHandler", "'handler: anotherHandler'");

    valueString.reset(WebViewTest::javascriptResultToCString(message));

    webkit_javascript_result_unref(message);

    g_assert_cmpstr(valueString.get(), ==, "handler: anotherHandler");

    // Unregistering a handler and re-registering again under the same name should work.

    // TODO Enable after https://bugs.webkit.org/show_bug.cgi?id=138142 gets fixed.

#if 0

    test->unregisterHandler("msg");

    javascriptResult = test->runJavaScriptAndWaitUntilFinished("window.webkit.messageHandlers.msg.postMessage('42');", &error.outPtr());

    g_assert(!javascriptResult);

    g_assert(error.get());

    // Re-registering a handler that has been unregistered must work

    g_assert(test->registerHandler("msg"));

    message = test->postMessageAndWaitUntilReceived("msg", "'handler: msg'");

    valueString.reset(WebViewTest::javascriptResultToCString(message));

    webkit_javascript_result_unref(message);

    g_assert_cmpstr(valueString.get(), ==, "handler: msg");

#endif

}

    UserScriptMessageTest::add("WebKitUserContentManager", "script-message-received", testUserContentManagerScriptMessageReceived);

2014-10-28  Adrian Perez de Castro  <aperez@igalia.com>

        [GTK] Support script message handlers WebKitUserContentManager

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

        Reviewed by NOBODY (OOPS!).

        Support user script message handlers in WebKitUserContentManager.

        This needs building with ENABLE_USER_MESSAGE_HANDLERS, for which

        an option is added to the CMake build files. The option is disabled

        globally by default, and the WebKitGTK port enables it. On the API

        level, two new methods to register and unregister names are provided

        in the "window.webkit" namespace, and on message reception the

        "WebKitUserContentManager::script-message-received" signal is

        emitted, using the registered names as signal detail.

        * Source/cmake/OptionsGTK.cmake: For the GTK port, enable the

        ENABLE_USER_MESSAGE_HANDLERS feature by default.

        * Source/cmake/WebKitFeatures.cmake: Add feature description for

        ENABLE_USER_MESSAGE_HANDLERS, disabled by default.