Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitWebContext.cpp - platform/external/chromium_org/third_party/WebKit - Git at Google

 /*
  * Copyright (C) 2011 Igalia S.L.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2,1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */

 #include "config.h"

 #include "LoadTrackingTest.h"
 #include "WebKitTestServer.h"
 #include <gtk/gtk.h>
 #include <webkit2/webkit2.h>
 #include <wtf/HashMap.h>
 #include <wtf/gobject/GOwnPtr.h>
 #include <wtf/gobject/GRefPtr.h>
 #include <wtf/text/StringHash.h>

 static WebKitTestServer* kServer;

 static void testWebContextDefault(Test* test, gconstpointer)
 {
     // Check there's a single instance of the default web context.
     g_assert(webkit_web_context_get_default() == webkit_web_context_get_default());
 }

 class PluginsTest: public Test {
 public:
     MAKE_GLIB_TEST_FIXTURE(PluginsTest);

     PluginsTest()
         : m_context(webkit_web_context_get_default())
         , m_mainLoop(g_main_loop_new(0, TRUE))
         , m_plugins(0)
     {
         webkit_web_context_set_additional_plugins_directory(m_context, WEBKIT_TEST_PLUGIN_DIR);
     }

     ~PluginsTest()
     {
         g_main_loop_unref(m_mainLoop);
         g_list_free_full(m_plugins, g_object_unref);
     }

     static void getPluginsAsyncReadyCallback(GObject*, GAsyncResult* result, PluginsTest* test)
     {
         test->m_plugins = webkit_web_context_get_plugins_finish(test->m_context, result, 0);
         g_main_loop_quit(test->m_mainLoop);
     }

     GList* getPlugins()
     {
         g_list_free_full(m_plugins, g_object_unref);
         webkit_web_context_get_plugins(m_context, 0, reinterpret_cast<GAsyncReadyCallback>(getPluginsAsyncReadyCallback), this);
         g_main_loop_run(m_mainLoop);
         return m_plugins;
     }

     WebKitWebContext* m_context;
     GMainLoop* m_mainLoop;
     GList* m_plugins;
 };

 static void testWebContextGetPlugins(PluginsTest* test, gconstpointer)
 {
     GList* plugins = test->getPlugins();
     g_assert(plugins);

     GRefPtr<WebKitPlugin> testPlugin;
     for (GList* item = plugins; item; item = g_list_next(item)) {
         WebKitPlugin* plugin = WEBKIT_PLUGIN(item->data);
         test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(plugin));
         if (!g_strcmp0(webkit_plugin_get_name(plugin), "WebKit Test PlugIn")) {
             testPlugin = plugin;
             break;
         }
     }
     g_assert(WEBKIT_IS_PLUGIN(testPlugin.get()));

     GOwnPtr<char> pluginPath(g_build_filename(WEBKIT_TEST_PLUGIN_DIR, "libtestnetscapeplugin.so", NULL));
     g_assert_cmpstr(webkit_plugin_get_path(testPlugin.get()), ==, pluginPath.get());
     g_assert_cmpstr(webkit_plugin_get_description(testPlugin.get()), ==, "Simple Netscape® plug-in that handles test content for WebKit");
     GList* mimeInfoList = webkit_plugin_get_mime_info_list(testPlugin.get());
     g_assert(mimeInfoList);
     g_assert_cmpuint(g_list_length(mimeInfoList), ==, 2);

     WebKitMimeInfo* mimeInfo = static_cast<WebKitMimeInfo*>(mimeInfoList->data);
     g_assert_cmpstr(webkit_mime_info_get_mime_type(mimeInfo), ==, "image/png");
     g_assert_cmpstr(webkit_mime_info_get_description(mimeInfo), ==, "png image");
     const gchar* const* extensions = webkit_mime_info_get_extensions(mimeInfo);
     g_assert(extensions);
     g_assert_cmpstr(extensions[0], ==, "png");

     mimeInfoList = g_list_next(mimeInfoList);
     mimeInfo = static_cast<WebKitMimeInfo*>(mimeInfoList->data);
     g_assert_cmpstr(webkit_mime_info_get_mime_type(mimeInfo), ==, "application/x-webkit-test-netscape");
     g_assert_cmpstr(webkit_mime_info_get_description(mimeInfo), ==, "test netscape content");
     extensions = webkit_mime_info_get_extensions(mimeInfo);
     g_assert(extensions);
     g_assert_cmpstr(extensions[0], ==, "testnetscape");
 }

 static const char* kBarHTML = "<html><body>Bar</body></html>";
 static const char* kEchoHTMLFormat = "<html><body>%s</body></html>";

 class URISchemeTest: public LoadTrackingTest {
 public:
     MAKE_GLIB_TEST_FIXTURE(URISchemeTest);

     struct URISchemeHandler {
         URISchemeHandler()
             : replyLength(0)
             , replyWithPath(false)
         {
         }

         URISchemeHandler(const char* reply, int replyLength, const char* mimeType, bool replyWithPath = false)
             : reply(reply)
             , replyLength(replyLength)
             , mimeType(mimeType)
             , replyWithPath(replyWithPath)
         {
         }

         CString reply;
         int replyLength;
         CString mimeType;
         bool replyWithPath;
     };

     static void uriSchemeRequestCallback(WebKitURISchemeRequest* request, gpointer userData)
     {
         URISchemeTest* test = static_cast<URISchemeTest*>(userData);
         test->m_uriSchemeRequest = request;
         test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(request));

         g_assert(webkit_uri_scheme_request_get_web_view(request) == test->m_webView);

         GRefPtr<GInputStream> inputStream = adoptGRef(g_memory_input_stream_new());
         test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(inputStream.get()));

         String scheme(String::fromUTF8(webkit_uri_scheme_request_get_scheme(request)));
         g_assert(!scheme.isEmpty());
         g_assert(test->m_handlersMap.contains(scheme));
         const URISchemeHandler& handler = test->m_handlersMap.get(scheme);

         if (handler.replyWithPath) {
             char* replyHTML = g_strdup_printf(handler.reply.data(), webkit_uri_scheme_request_get_path(request));
             g_memory_input_stream_add_data(G_MEMORY_INPUT_STREAM(inputStream.get()), replyHTML, strlen(replyHTML), g_free);
         } else if (!handler.reply.isNull())
             g_memory_input_stream_add_data(G_MEMORY_INPUT_STREAM(inputStream.get()), handler.reply.data(), handler.reply.length(), 0);
         webkit_uri_scheme_request_finish(request, inputStream.get(), handler.replyLength, handler.mimeType.data());
     }

     void registerURISchemeHandler(const char* scheme, const char* reply, int replyLength, const char* mimeType, bool replyWithPath = false)
     {
         m_handlersMap.set(String::fromUTF8(scheme), URISchemeHandler(reply, replyLength, mimeType, replyWithPath));
         webkit_web_context_register_uri_scheme(webkit_web_context_get_default(), scheme, uriSchemeRequestCallback, this, 0);
     }

     GRefPtr<WebKitURISchemeRequest> m_uriSchemeRequest;
     HashMap<String, URISchemeHandler> m_handlersMap;
 };

 static void testWebContextURIScheme(URISchemeTest* test, gconstpointer)
 {
     test->registerURISchemeHandler("foo", kBarHTML, strlen(kBarHTML), "text/html");
     test->loadURI("foo:blank");
     test->waitUntilLoadFinished();
     size_t mainResourceDataSize = 0;
     const char* mainResourceData = test->mainResourceData(mainResourceDataSize);
     g_assert_cmpint(mainResourceDataSize, ==, strlen(kBarHTML));
     g_assert(!strncmp(mainResourceData, kBarHTML, mainResourceDataSize));

     test->registerURISchemeHandler("echo", kEchoHTMLFormat, -1, "text/html", true);
     test->loadURI("echo:hello world");
     test->waitUntilLoadFinished();
     GOwnPtr<char> echoHTML(g_strdup_printf(kEchoHTMLFormat, webkit_uri_scheme_request_get_path(test->m_uriSchemeRequest.get())));
     mainResourceDataSize = 0;
     mainResourceData = test->mainResourceData(mainResourceDataSize);
     g_assert_cmpint(mainResourceDataSize, ==, strlen(echoHTML.get()));
     g_assert(!strncmp(mainResourceData, echoHTML.get(), mainResourceDataSize));

     test->registerURISchemeHandler("nomime", kBarHTML, -1, 0);
     test->m_loadEvents.clear();
     test->loadURI("nomime:foo bar");
     test->waitUntilLoadFinished();
     g_assert(test->m_loadEvents.contains(LoadTrackingTest::ProvisionalLoadFailed));

     test->registerURISchemeHandler("empty", 0, 0, "text/html");
     test->m_loadEvents.clear();
     test->loadURI("empty:nothing");
     test->waitUntilLoadFinished();
     g_assert(!test->m_loadEvents.contains(LoadTrackingTest::ProvisionalLoadFailed));
     g_assert(!test->m_loadEvents.contains(LoadTrackingTest::LoadFailed));
 }

 static void testWebContextSpellChecker(Test* test, gconstpointer)
 {
     WebKitWebContext* webContext = webkit_web_context_get_default();

     // Check what happens if no spell checking language has been set.
     const gchar* const* currentLanguage = webkit_web_context_get_spell_checking_languages(webContext);
     g_assert(!currentLanguage);

     // Set the language to a specific one.
     GRefPtr<GPtrArray> languages = adoptGRef(g_ptr_array_new());
     g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("en_US")));
     g_ptr_array_add(languages.get(), 0);
     webkit_web_context_set_spell_checking_languages(webContext, reinterpret_cast<const char* const*>(languages->pdata));
     currentLanguage = webkit_web_context_get_spell_checking_languages(webContext);
     g_assert_cmpuint(g_strv_length(const_cast<char**>(currentLanguage)), ==, 1);
     g_assert_cmpstr(currentLanguage[0], ==, "en_US");

     // Set the language string to list of valid languages.
     g_ptr_array_remove_index_fast(languages.get(), languages->len - 1);
     g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("en_GB")));
     g_ptr_array_add(languages.get(), 0);
     webkit_web_context_set_spell_checking_languages(webContext, reinterpret_cast<const char* const*>(languages->pdata));
     currentLanguage = webkit_web_context_get_spell_checking_languages(webContext);
     g_assert_cmpuint(g_strv_length(const_cast<char**>(currentLanguage)), ==, 2);
     g_assert_cmpstr(currentLanguage[0], ==, "en_US");
     g_assert_cmpstr(currentLanguage[1], ==, "en_GB");

     // Try passing a wrong language along with good ones.
     g_ptr_array_remove_index_fast(languages.get(), languages->len - 1);
     g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("bd_WR")));
     g_ptr_array_add(languages.get(), 0);
     webkit_web_context_set_spell_checking_languages(webContext, reinterpret_cast<const char* const*>(languages->pdata));
     currentLanguage = webkit_web_context_get_spell_checking_languages(webContext);
     g_assert_cmpuint(g_strv_length(const_cast<char**>(currentLanguage)), ==, 2);
     g_assert_cmpstr(currentLanguage[0], ==, "en_US");
     g_assert_cmpstr(currentLanguage[1], ==, "en_GB");

     // Try passing a list with only wrong languages.
     languages = adoptGRef(g_ptr_array_new());
     g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("bd_WR")));
     g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("wr_BD")));
     g_ptr_array_add(languages.get(), 0);
     webkit_web_context_set_spell_checking_languages(webContext, reinterpret_cast<const char* const*>(languages->pdata));
     currentLanguage = webkit_web_context_get_spell_checking_languages(webContext);
     g_assert(!currentLanguage);

     // Check disabling and re-enabling spell checking.
     webkit_web_context_set_spell_checking_enabled(webContext, FALSE);
     g_assert(!webkit_web_context_get_spell_checking_enabled(webContext));
     webkit_web_context_set_spell_checking_enabled(webContext, TRUE);
     g_assert(webkit_web_context_get_spell_checking_enabled(webContext));
 }

 static void testWebContextLanguages(WebViewTest* test, gconstpointer)
 {
     static const char* expectedDefaultLanguage = "en";
     test->loadURI(kServer->getURIForPath("/").data());
     test->waitUntilLoadFinished();
     size_t mainResourceDataSize = 0;
     const char* mainResourceData = test->mainResourceData(mainResourceDataSize);
     g_assert_cmpuint(mainResourceDataSize, ==, strlen(expectedDefaultLanguage));
     g_assert(!strncmp(mainResourceData, expectedDefaultLanguage, mainResourceDataSize));

     GRefPtr<GPtrArray> languages = adoptGRef(g_ptr_array_new());
     g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("en")));
     g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("ES_es")));
     g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("dE")));
     g_ptr_array_add(languages.get(), 0);
     webkit_web_context_set_preferred_languages(webkit_web_context_get_default(), reinterpret_cast<const char* const*>(languages->pdata));

     static const char* expectedLanguages = "en, es-es;q=0.90, de;q=0.80";
     test->loadURI(kServer->getURIForPath("/").data());
     test->waitUntilLoadFinished();
     mainResourceDataSize = 0;
     mainResourceData = test->mainResourceData(mainResourceDataSize);
     g_assert_cmpuint(mainResourceDataSize, ==, strlen(expectedLanguages));
     g_assert(!strncmp(mainResourceData, expectedLanguages, mainResourceDataSize));
 }

 static void serverCallback(SoupServer* server, SoupMessage* message, const char* path, GHashTable*, SoupClientContext*, gpointer)
 {
     if (message->method != SOUP_METHOD_GET) {
         soup_message_set_status(message, SOUP_STATUS_NOT_IMPLEMENTED);
         return;
     }

     if (g_str_equal(path, "/")) {
         const char* acceptLanguage = soup_message_headers_get_one(message->request_headers, "Accept-Language");
         soup_message_set_status(message, SOUP_STATUS_OK);
         soup_message_body_append(message->response_body, SOUP_MEMORY_COPY, acceptLanguage, strlen(acceptLanguage));
         soup_message_body_complete(message->response_body);
     } else
         soup_message_set_status(message, SOUP_STATUS_NOT_FOUND);
 }

 class SecurityPolicyTest: public Test {
 public:
     MAKE_GLIB_TEST_FIXTURE(SecurityPolicyTest);

     enum SecurityPolicy {
         Local = 1 << 1,
         NoAccess = 1 << 2,
         DisplayIsolated = 1 << 3,
         Secure = 1 << 4,
         CORSEnabled = 1 << 5,
         EmptyDocument = 1 << 6
     };

     SecurityPolicyTest()
         : m_manager(webkit_web_context_get_security_manager(webkit_web_context_get_default()))
     {
     }

     void verifyThatSchemeMatchesPolicy(const char* scheme, unsigned policy)
     {
         if (policy & Local)
             g_assert(webkit_security_manager_uri_scheme_is_local(m_manager, scheme));
         else
             g_assert(!webkit_security_manager_uri_scheme_is_local(m_manager, scheme));
         if (policy & NoAccess)
             g_assert(webkit_security_manager_uri_scheme_is_no_access(m_manager, scheme));
         else
             g_assert(!webkit_security_manager_uri_scheme_is_no_access(m_manager, scheme));
         if (policy & DisplayIsolated)
             g_assert(webkit_security_manager_uri_scheme_is_display_isolated(m_manager, scheme));
         else
             g_assert(!webkit_security_manager_uri_scheme_is_display_isolated(m_manager, scheme));
         if (policy & Secure)
             g_assert(webkit_security_manager_uri_scheme_is_secure(m_manager, scheme));
         else
             g_assert(!webkit_security_manager_uri_scheme_is_secure(m_manager, scheme));
         if (policy & CORSEnabled)
             g_assert(webkit_security_manager_uri_scheme_is_cors_enabled(m_manager, scheme));
         else
             g_assert(!webkit_security_manager_uri_scheme_is_cors_enabled(m_manager, scheme));
         if (policy & EmptyDocument)
             g_assert(webkit_security_manager_uri_scheme_is_empty_document(m_manager, scheme));
         else
             g_assert(!webkit_security_manager_uri_scheme_is_empty_document(m_manager, scheme));
     }

     WebKitSecurityManager* m_manager;
 };

 static void testWebContextSecurityPolicy(SecurityPolicyTest* test, gconstpointer)
 {
     // VerifyThatSchemeMatchesPolicy default policy for well known schemes.
     test->verifyThatSchemeMatchesPolicy("http", SecurityPolicyTest::CORSEnabled);
     test->verifyThatSchemeMatchesPolicy("https", SecurityPolicyTest::CORSEnabled | SecurityPolicyTest::Secure);
     test->verifyThatSchemeMatchesPolicy("file", SecurityPolicyTest::Local);
     test->verifyThatSchemeMatchesPolicy("data", SecurityPolicyTest::NoAccess | SecurityPolicyTest::Secure);
     test->verifyThatSchemeMatchesPolicy("about", SecurityPolicyTest::NoAccess | SecurityPolicyTest::Secure | SecurityPolicyTest::EmptyDocument);

     // Custom scheme.
     test->verifyThatSchemeMatchesPolicy("foo", 0);

     webkit_security_manager_register_uri_scheme_as_local(test->m_manager, "foo");
     test->verifyThatSchemeMatchesPolicy("foo", SecurityPolicyTest::Local);
     webkit_security_manager_register_uri_scheme_as_no_access(test->m_manager, "foo");
     test->verifyThatSchemeMatchesPolicy("foo", SecurityPolicyTest::Local | SecurityPolicyTest::NoAccess);
     webkit_security_manager_register_uri_scheme_as_display_isolated(test->m_manager, "foo");
     test->verifyThatSchemeMatchesPolicy("foo", SecurityPolicyTest::Local | SecurityPolicyTest::NoAccess | SecurityPolicyTest::DisplayIsolated);
     webkit_security_manager_register_uri_scheme_as_secure(test->m_manager, "foo");
     test->verifyThatSchemeMatchesPolicy("foo", SecurityPolicyTest::Local | SecurityPolicyTest::NoAccess | SecurityPolicyTest::DisplayIsolated | SecurityPolicyTest::Secure);
     webkit_security_manager_register_uri_scheme_as_cors_enabled(test->m_manager, "foo");
     test->verifyThatSchemeMatchesPolicy("foo", SecurityPolicyTest::Local | SecurityPolicyTest::NoAccess | SecurityPolicyTest::DisplayIsolated | SecurityPolicyTest::Secure
                 | SecurityPolicyTest::CORSEnabled);
     webkit_security_manager_register_uri_scheme_as_empty_document(test->m_manager, "foo");
     test->verifyThatSchemeMatchesPolicy("foo", SecurityPolicyTest::Local | SecurityPolicyTest::NoAccess | SecurityPolicyTest::DisplayIsolated | SecurityPolicyTest::Secure
                 | SecurityPolicyTest::CORSEnabled | SecurityPolicyTest::EmptyDocument);
 }

 void beforeAll()
 {
     kServer = new WebKitTestServer();
     kServer->run(serverCallback);

     Test::add("WebKitWebContext", "default-context", testWebContextDefault);
     PluginsTest::add("WebKitWebContext", "get-plugins", testWebContextGetPlugins);
     URISchemeTest::add("WebKitWebContext", "uri-scheme", testWebContextURIScheme);
     Test::add("WebKitWebContext", "spell-checker", testWebContextSpellChecker);
     WebViewTest::add("WebKitWebContext", "languages", testWebContextLanguages);
     SecurityPolicyTest::add("WebKitSecurityManager", "security-policy", testWebContextSecurityPolicy);
 }

 void afterAll()
 {
     delete kServer;
 }
	/*
	* Copyright (C) 2011 Igalia S.L.
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2,1 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Library General Public License for more details.
	*
	* You should have received a copy of the GNU Library General Public License
	* along with this library; see the file COPYING.LIB. If not, write to
	* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	* Boston, MA 02110-1301, USA.
	*/

	#include "config.h"

	#include "LoadTrackingTest.h"
	#include "WebKitTestServer.h"
	#include <gtk/gtk.h>
	#include <webkit2/webkit2.h>
	#include <wtf/HashMap.h>
	#include <wtf/gobject/GOwnPtr.h>
	#include <wtf/gobject/GRefPtr.h>
	#include <wtf/text/StringHash.h>

	static WebKitTestServer* kServer;

	static void testWebContextDefault(Test* test, gconstpointer)
	{
	// Check there's a single instance of the default web context.
	g_assert(webkit_web_context_get_default() == webkit_web_context_get_default());
	}

	class PluginsTest: public Test {
	public:
	MAKE_GLIB_TEST_FIXTURE(PluginsTest);

	PluginsTest()
	: m_context(webkit_web_context_get_default())
	, m_mainLoop(g_main_loop_new(0, TRUE))
	, m_plugins(0)
	{
	webkit_web_context_set_additional_plugins_directory(m_context, WEBKIT_TEST_PLUGIN_DIR);
	}

	~PluginsTest()
	{
	g_main_loop_unref(m_mainLoop);
	g_list_free_full(m_plugins, g_object_unref);
	}

	static void getPluginsAsyncReadyCallback(GObject, GAsyncResult result, PluginsTest* test)
	{
	test->m_plugins = webkit_web_context_get_plugins_finish(test->m_context, result, 0);
	g_main_loop_quit(test->m_mainLoop);
	}

	GList* getPlugins()
	{
	g_list_free_full(m_plugins, g_object_unref);
	webkit_web_context_get_plugins(m_context, 0, reinterpret_cast<GAsyncReadyCallback>(getPluginsAsyncReadyCallback), this);
	g_main_loop_run(m_mainLoop);
	return m_plugins;
	}

	WebKitWebContext* m_context;
	GMainLoop* m_mainLoop;
	GList* m_plugins;
	};

	static void testWebContextGetPlugins(PluginsTest* test, gconstpointer)
	{
	GList* plugins = test->getPlugins();
	g_assert(plugins);

	GRefPtr<WebKitPlugin> testPlugin;
	for (GList* item = plugins; item; item = g_list_next(item)) {
	WebKitPlugin* plugin = WEBKIT_PLUGIN(item->data);
	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(plugin));
	if (!g_strcmp0(webkit_plugin_get_name(plugin), "WebKit Test PlugIn")) {
	testPlugin = plugin;
	break;
	}
	}
	g_assert(WEBKIT_IS_PLUGIN(testPlugin.get()));

	GOwnPtr<char> pluginPath(g_build_filename(WEBKIT_TEST_PLUGIN_DIR, "libtestnetscapeplugin.so", NULL));
	g_assert_cmpstr(webkit_plugin_get_path(testPlugin.get()), ==, pluginPath.get());
	g_assert_cmpstr(webkit_plugin_get_description(testPlugin.get()), ==, "Simple Netscape® plug-in that handles test content for WebKit");
	GList* mimeInfoList = webkit_plugin_get_mime_info_list(testPlugin.get());
	g_assert(mimeInfoList);
	g_assert_cmpuint(g_list_length(mimeInfoList), ==, 2);

	WebKitMimeInfo* mimeInfo = static_cast<WebKitMimeInfo*>(mimeInfoList->data);
	g_assert_cmpstr(webkit_mime_info_get_mime_type(mimeInfo), ==, "image/png");
	g_assert_cmpstr(webkit_mime_info_get_description(mimeInfo), ==, "png image");
	const gchar* const* extensions = webkit_mime_info_get_extensions(mimeInfo);
	g_assert(extensions);
	g_assert_cmpstr(extensions[0], ==, "png");

	mimeInfoList = g_list_next(mimeInfoList);
	mimeInfo = static_cast<WebKitMimeInfo*>(mimeInfoList->data);
	g_assert_cmpstr(webkit_mime_info_get_mime_type(mimeInfo), ==, "application/x-webkit-test-netscape");
	g_assert_cmpstr(webkit_mime_info_get_description(mimeInfo), ==, "test netscape content");
	extensions = webkit_mime_info_get_extensions(mimeInfo);
	g_assert(extensions);
	g_assert_cmpstr(extensions[0], ==, "testnetscape");
	}

	static const char* kBarHTML = "<html><body>Bar</body></html>";
	static const char* kEchoHTMLFormat = "<html><body>%s</body></html>";

	class URISchemeTest: public LoadTrackingTest {
	public:
	MAKE_GLIB_TEST_FIXTURE(URISchemeTest);

	struct URISchemeHandler {
	URISchemeHandler()
	: replyLength(0)
	, replyWithPath(false)
	{
	}

	URISchemeHandler(const char* reply, int replyLength, const char* mimeType, bool replyWithPath = false)
	: reply(reply)
	, replyLength(replyLength)
	, mimeType(mimeType)
	, replyWithPath(replyWithPath)
	{
	}

	CString reply;
	int replyLength;
	CString mimeType;
	bool replyWithPath;
	};

	static void uriSchemeRequestCallback(WebKitURISchemeRequest* request, gpointer userData)
	{
	URISchemeTest* test = static_cast<URISchemeTest*>(userData);
	test->m_uriSchemeRequest = request;
	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(request));

	g_assert(webkit_uri_scheme_request_get_web_view(request) == test->m_webView);

	GRefPtr<GInputStream> inputStream = adoptGRef(g_memory_input_stream_new());
	test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(inputStream.get()));

	String scheme(String::fromUTF8(webkit_uri_scheme_request_get_scheme(request)));
	g_assert(!scheme.isEmpty());
	g_assert(test->m_handlersMap.contains(scheme));
	const URISchemeHandler& handler = test->m_handlersMap.get(scheme);

	if (handler.replyWithPath) {
	char* replyHTML = g_strdup_printf(handler.reply.data(), webkit_uri_scheme_request_get_path(request));
	g_memory_input_stream_add_data(G_MEMORY_INPUT_STREAM(inputStream.get()), replyHTML, strlen(replyHTML), g_free);
	} else if (!handler.reply.isNull())
	g_memory_input_stream_add_data(G_MEMORY_INPUT_STREAM(inputStream.get()), handler.reply.data(), handler.reply.length(), 0);
	webkit_uri_scheme_request_finish(request, inputStream.get(), handler.replyLength, handler.mimeType.data());
	}

	void registerURISchemeHandler(const char* scheme, const char* reply, int replyLength, const char* mimeType, bool replyWithPath = false)
	{
	m_handlersMap.set(String::fromUTF8(scheme), URISchemeHandler(reply, replyLength, mimeType, replyWithPath));
	webkit_web_context_register_uri_scheme(webkit_web_context_get_default(), scheme, uriSchemeRequestCallback, this, 0);
	}

	GRefPtr<WebKitURISchemeRequest> m_uriSchemeRequest;
	HashMap<String, URISchemeHandler> m_handlersMap;
	};

	static void testWebContextURIScheme(URISchemeTest* test, gconstpointer)
	{
	test->registerURISchemeHandler("foo", kBarHTML, strlen(kBarHTML), "text/html");
	test->loadURI("foo:blank");
	test->waitUntilLoadFinished();
	size_t mainResourceDataSize = 0;
	const char* mainResourceData = test->mainResourceData(mainResourceDataSize);
	g_assert_cmpint(mainResourceDataSize, ==, strlen(kBarHTML));
	g_assert(!strncmp(mainResourceData, kBarHTML, mainResourceDataSize));

	test->registerURISchemeHandler("echo", kEchoHTMLFormat, -1, "text/html", true);
	test->loadURI("echo:hello world");
	test->waitUntilLoadFinished();
	GOwnPtr<char> echoHTML(g_strdup_printf(kEchoHTMLFormat, webkit_uri_scheme_request_get_path(test->m_uriSchemeRequest.get())));
	mainResourceDataSize = 0;
	mainResourceData = test->mainResourceData(mainResourceDataSize);
	g_assert_cmpint(mainResourceDataSize, ==, strlen(echoHTML.get()));
	g_assert(!strncmp(mainResourceData, echoHTML.get(), mainResourceDataSize));

	test->registerURISchemeHandler("nomime", kBarHTML, -1, 0);
	test->m_loadEvents.clear();
	test->loadURI("nomime:foo bar");
	test->waitUntilLoadFinished();
	g_assert(test->m_loadEvents.contains(LoadTrackingTest::ProvisionalLoadFailed));

	test->registerURISchemeHandler("empty", 0, 0, "text/html");
	test->m_loadEvents.clear();
	test->loadURI("empty:nothing");
	test->waitUntilLoadFinished();
	g_assert(!test->m_loadEvents.contains(LoadTrackingTest::ProvisionalLoadFailed));
	g_assert(!test->m_loadEvents.contains(LoadTrackingTest::LoadFailed));
	}

	static void testWebContextSpellChecker(Test* test, gconstpointer)
	{
	WebKitWebContext* webContext = webkit_web_context_get_default();

	// Check what happens if no spell checking language has been set.
	const gchar* const* currentLanguage = webkit_web_context_get_spell_checking_languages(webContext);
	g_assert(!currentLanguage);

	// Set the language to a specific one.
	GRefPtr<GPtrArray> languages = adoptGRef(g_ptr_array_new());
	g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("en_US")));
	g_ptr_array_add(languages.get(), 0);
	webkit_web_context_set_spell_checking_languages(webContext, reinterpret_cast<const char* const*>(languages->pdata));
	currentLanguage = webkit_web_context_get_spell_checking_languages(webContext);
	g_assert_cmpuint(g_strv_length(const_cast<char**>(currentLanguage)), ==, 1);
	g_assert_cmpstr(currentLanguage[0], ==, "en_US");

	// Set the language string to list of valid languages.
	g_ptr_array_remove_index_fast(languages.get(), languages->len - 1);
	g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("en_GB")));
	g_ptr_array_add(languages.get(), 0);
	webkit_web_context_set_spell_checking_languages(webContext, reinterpret_cast<const char* const*>(languages->pdata));
	currentLanguage = webkit_web_context_get_spell_checking_languages(webContext);
	g_assert_cmpuint(g_strv_length(const_cast<char**>(currentLanguage)), ==, 2);
	g_assert_cmpstr(currentLanguage[0], ==, "en_US");
	g_assert_cmpstr(currentLanguage[1], ==, "en_GB");

	// Try passing a wrong language along with good ones.
	g_ptr_array_remove_index_fast(languages.get(), languages->len - 1);
	g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("bd_WR")));
	g_ptr_array_add(languages.get(), 0);
	webkit_web_context_set_spell_checking_languages(webContext, reinterpret_cast<const char* const*>(languages->pdata));
	currentLanguage = webkit_web_context_get_spell_checking_languages(webContext);
	g_assert_cmpuint(g_strv_length(const_cast<char**>(currentLanguage)), ==, 2);
	g_assert_cmpstr(currentLanguage[0], ==, "en_US");
	g_assert_cmpstr(currentLanguage[1], ==, "en_GB");

	// Try passing a list with only wrong languages.
	languages = adoptGRef(g_ptr_array_new());
	g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("bd_WR")));
	g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("wr_BD")));
	g_ptr_array_add(languages.get(), 0);
	webkit_web_context_set_spell_checking_languages(webContext, reinterpret_cast<const char* const*>(languages->pdata));
	currentLanguage = webkit_web_context_get_spell_checking_languages(webContext);
	g_assert(!currentLanguage);

	// Check disabling and re-enabling spell checking.
	webkit_web_context_set_spell_checking_enabled(webContext, FALSE);
	g_assert(!webkit_web_context_get_spell_checking_enabled(webContext));
	webkit_web_context_set_spell_checking_enabled(webContext, TRUE);
	g_assert(webkit_web_context_get_spell_checking_enabled(webContext));
	}

	static void testWebContextLanguages(WebViewTest* test, gconstpointer)
	{
	static const char* expectedDefaultLanguage = "en";
	test->loadURI(kServer->getURIForPath("/").data());
	test->waitUntilLoadFinished();
	size_t mainResourceDataSize = 0;
	const char* mainResourceData = test->mainResourceData(mainResourceDataSize);
	g_assert_cmpuint(mainResourceDataSize, ==, strlen(expectedDefaultLanguage));
	g_assert(!strncmp(mainResourceData, expectedDefaultLanguage, mainResourceDataSize));

	GRefPtr<GPtrArray> languages = adoptGRef(g_ptr_array_new());
	g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("en")));
	g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("ES_es")));
	g_ptr_array_add(languages.get(), const_cast<gpointer>(static_cast<const void*>("dE")));
	g_ptr_array_add(languages.get(), 0);
	webkit_web_context_set_preferred_languages(webkit_web_context_get_default(), reinterpret_cast<const char* const*>(languages->pdata));

	static const char* expectedLanguages = "en, es-es;q=0.90, de;q=0.80";
	test->loadURI(kServer->getURIForPath("/").data());
	test->waitUntilLoadFinished();
	mainResourceDataSize = 0;
	mainResourceData = test->mainResourceData(mainResourceDataSize);
	g_assert_cmpuint(mainResourceDataSize, ==, strlen(expectedLanguages));
	g_assert(!strncmp(mainResourceData, expectedLanguages, mainResourceDataSize));
	}

	static void serverCallback(SoupServer* server, SoupMessage* message, const char* path, GHashTable, SoupClientContext, gpointer)
	{
	if (message->method != SOUP_METHOD_GET) {
	soup_message_set_status(message, SOUP_STATUS_NOT_IMPLEMENTED);
	return;
	}

	if (g_str_equal(path, "/")) {
	const char* acceptLanguage = soup_message_headers_get_one(message->request_headers, "Accept-Language");
	soup_message_set_status(message, SOUP_STATUS_OK);
	soup_message_body_append(message->response_body, SOUP_MEMORY_COPY, acceptLanguage, strlen(acceptLanguage));
	soup_message_body_complete(message->response_body);
	} else
	soup_message_set_status(message, SOUP_STATUS_NOT_FOUND);
	}

	class SecurityPolicyTest: public Test {
	public:
	MAKE_GLIB_TEST_FIXTURE(SecurityPolicyTest);

	enum SecurityPolicy {
	Local = 1 << 1,
	NoAccess = 1 << 2,
	DisplayIsolated = 1 << 3,
	Secure = 1 << 4,
	CORSEnabled = 1 << 5,
	EmptyDocument = 1 << 6
	};

	SecurityPolicyTest()
	: m_manager(webkit_web_context_get_security_manager(webkit_web_context_get_default()))
	{
	}

	void verifyThatSchemeMatchesPolicy(const char* scheme, unsigned policy)
	{
	if (policy & Local)
	g_assert(webkit_security_manager_uri_scheme_is_local(m_manager, scheme));
	else
	g_assert(!webkit_security_manager_uri_scheme_is_local(m_manager, scheme));
	if (policy & NoAccess)
	g_assert(webkit_security_manager_uri_scheme_is_no_access(m_manager, scheme));
	else
	g_assert(!webkit_security_manager_uri_scheme_is_no_access(m_manager, scheme));
	if (policy & DisplayIsolated)
	g_assert(webkit_security_manager_uri_scheme_is_display_isolated(m_manager, scheme));
	else
	g_assert(!webkit_security_manager_uri_scheme_is_display_isolated(m_manager, scheme));
	if (policy & Secure)
	g_assert(webkit_security_manager_uri_scheme_is_secure(m_manager, scheme));
	else
	g_assert(!webkit_security_manager_uri_scheme_is_secure(m_manager, scheme));
	if (policy & CORSEnabled)
	g_assert(webkit_security_manager_uri_scheme_is_cors_enabled(m_manager, scheme));
	else
	g_assert(!webkit_security_manager_uri_scheme_is_cors_enabled(m_manager, scheme));
	if (policy & EmptyDocument)
	g_assert(webkit_security_manager_uri_scheme_is_empty_document(m_manager, scheme));
	else
	g_assert(!webkit_security_manager_uri_scheme_is_empty_document(m_manager, scheme));
	}

	WebKitSecurityManager* m_manager;
	};

	static void testWebContextSecurityPolicy(SecurityPolicyTest* test, gconstpointer)
	{
	// VerifyThatSchemeMatchesPolicy default policy for well known schemes.
	test->verifyThatSchemeMatchesPolicy("http", SecurityPolicyTest::CORSEnabled);
	test->verifyThatSchemeMatchesPolicy("https", SecurityPolicyTest::CORSEnabled \| SecurityPolicyTest::Secure);
	test->verifyThatSchemeMatchesPolicy("file", SecurityPolicyTest::Local);
	test->verifyThatSchemeMatchesPolicy("data", SecurityPolicyTest::NoAccess \| SecurityPolicyTest::Secure);
	test->verifyThatSchemeMatchesPolicy("about", SecurityPolicyTest::NoAccess \| SecurityPolicyTest::Secure \| SecurityPolicyTest::EmptyDocument);

	// Custom scheme.
	test->verifyThatSchemeMatchesPolicy("foo", 0);

	webkit_security_manager_register_uri_scheme_as_local(test->m_manager, "foo");
	test->verifyThatSchemeMatchesPolicy("foo", SecurityPolicyTest::Local);
	webkit_security_manager_register_uri_scheme_as_no_access(test->m_manager, "foo");
	test->verifyThatSchemeMatchesPolicy("foo", SecurityPolicyTest::Local \| SecurityPolicyTest::NoAccess);
	webkit_security_manager_register_uri_scheme_as_display_isolated(test->m_manager, "foo");
	test->verifyThatSchemeMatchesPolicy("foo", SecurityPolicyTest::Local \| SecurityPolicyTest::NoAccess \| SecurityPolicyTest::DisplayIsolated);
	webkit_security_manager_register_uri_scheme_as_secure(test->m_manager, "foo");
	test->verifyThatSchemeMatchesPolicy("foo", SecurityPolicyTest::Local \| SecurityPolicyTest::NoAccess \| SecurityPolicyTest::DisplayIsolated \| SecurityPolicyTest::Secure);
	webkit_security_manager_register_uri_scheme_as_cors_enabled(test->m_manager, "foo");
	test->verifyThatSchemeMatchesPolicy("foo", SecurityPolicyTest::Local \| SecurityPolicyTest::NoAccess \| SecurityPolicyTest::DisplayIsolated \| SecurityPolicyTest::Secure
	\| SecurityPolicyTest::CORSEnabled);
	webkit_security_manager_register_uri_scheme_as_empty_document(test->m_manager, "foo");
	test->verifyThatSchemeMatchesPolicy("foo", SecurityPolicyTest::Local \| SecurityPolicyTest::NoAccess \| SecurityPolicyTest::DisplayIsolated \| SecurityPolicyTest::Secure
	\| SecurityPolicyTest::CORSEnabled \| SecurityPolicyTest::EmptyDocument);
	}

	void beforeAll()
	{
	kServer = new WebKitTestServer();
	kServer->run(serverCallback);

	Test::add("WebKitWebContext", "default-context", testWebContextDefault);
	PluginsTest::add("WebKitWebContext", "get-plugins", testWebContextGetPlugins);
	URISchemeTest::add("WebKitWebContext", "uri-scheme", testWebContextURIScheme);
	Test::add("WebKitWebContext", "spell-checker", testWebContextSpellChecker);
	WebViewTest::add("WebKitWebContext", "languages", testWebContextLanguages);
	SecurityPolicyTest::add("WebKitSecurityManager", "security-policy", testWebContextSecurityPolicy);
	}

	void afterAll()
	{
	delete kServer;
	}