Imported WebKit commit cf4f8fc6f19b0629f51860cb2d4b25e139d07e00 (http://svn.webkit.org/repository/webkit/trunk@131592)

New snapshot that includes the build fixes for Mac OS X 10.6 and earlier as well
as the previously cherry-picked changes

40 files changed, 1554 insertions, 241 deletions

diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitDownloadClient.cpp b/Source/WebKit2/UIProcess/API/gtk/WebKitDownloadClient.cpp
index 6e72496ef..79c1c3e2a 100644
--- a/Source/WebKit2/UIProcess/API/gtk/WebKitDownloadClient.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitDownloadClient.cpp
@@ -34,13 +34,13 @@ using namespace WebKit;
 
 static void didStart(WKContextRef, WKDownloadRef wkDownload, const void* clientInfo)
 {
-    GRefPtr<WebKitDownload> download = webkitWebContextGetOrCreateDownload(wkDownload);
+    GRefPtr<WebKitDownload> download = webkitWebContextGetOrCreateDownload(toImpl(wkDownload));
     webkitWebContextDownloadStarted(WEBKIT_WEB_CONTEXT(clientInfo), download.get());
 }
 
 static void didReceiveResponse(WKContextRef, WKDownloadRef wkDownload, WKURLResponseRef wkResponse, const void* clientInfo)
 {
-    GRefPtr<WebKitDownload> download = webkitWebContextGetOrCreateDownload(wkDownload);
+    GRefPtr<WebKitDownload> download = webkitWebContextGetOrCreateDownload(toImpl(wkDownload));
     if (webkitDownloadIsCancelled(download.get()))
         return;
 
@@ -50,13 +50,13 @@ static void didReceiveResponse(WKContextRef, WKDownloadRef wkDownload, WKURLResp
 
 static void didReceiveData(WKContextRef, WKDownloadRef wkDownload, uint64_t length, const void* clientInfo)
 {
-    GRefPtr<WebKitDownload> download = webkitWebContextGetOrCreateDownload(wkDownload);
+    GRefPtr<WebKitDownload> download = webkitWebContextGetOrCreateDownload(toImpl(wkDownload));
     webkitDownloadNotifyProgress(download.get(), length);
 }
 
 static WKStringRef decideDestinationWithSuggestedFilename(WKContextRef, WKDownloadRef wkDownload, WKStringRef filename, bool* allowOverwrite, const void* clientInfo)
 {
-    GRefPtr<WebKitDownload> download = webkitWebContextGetOrCreateDownload(wkDownload);
+    GRefPtr<WebKitDownload> download = webkitWebContextGetOrCreateDownload(toImpl(wkDownload));
     CString destinationURI = webkitDownloadDecideDestinationWithSuggestedFilename(download.get(),
                                                                                   toImpl(filename)->string().utf8());
     return WKStringCreateWithUTF8CString(destinationURI.data());
@@ -64,33 +64,33 @@ static WKStringRef decideDestinationWithSuggestedFilename(WKContextRef, WKDownlo
 
 static void didCreateDestination(WKContextRef, WKDownloadRef wkDownload, WKStringRef path, const void* clientInfo)
 {
-    GRefPtr<WebKitDownload> download = webkitWebContextGetOrCreateDownload(wkDownload);
+    GRefPtr<WebKitDownload> download = webkitWebContextGetOrCreateDownload(toImpl(wkDownload));
     webkitDownloadDestinationCreated(download.get(), toImpl(path)->string().utf8());
 }
 
 static void didFail(WKContextRef, WKDownloadRef wkDownload, WKErrorRef error, const void *clientInfo)
 {
-    GRefPtr<WebKitDownload> download = webkitWebContextGetOrCreateDownload(wkDownload);
+    GRefPtr<WebKitDownload> download = webkitWebContextGetOrCreateDownload(toImpl(wkDownload));
     if (webkitDownloadIsCancelled(download.get())) {
         // Cancellation takes precedence over other errors.
         webkitDownloadCancelled(download.get());
     } else
         webkitDownloadFailed(download.get(), toImpl(error)->platformError());
-    webkitWebContextRemoveDownload(wkDownload);
+    webkitWebContextRemoveDownload(toImpl(wkDownload));
 }
 
 static void didCancel(WKContextRef, WKDownloadRef wkDownload, const void *clientInfo)
 {
-    GRefPtr<WebKitDownload> download = webkitWebContextGetOrCreateDownload(wkDownload);
+    GRefPtr<WebKitDownload> download = webkitWebContextGetOrCreateDownload(toImpl(wkDownload));
     webkitDownloadCancelled(download.get());
-    webkitWebContextRemoveDownload(wkDownload);
+    webkitWebContextRemoveDownload(toImpl(wkDownload));
 }
 
 static void didFinish(WKContextRef wkContext, WKDownloadRef wkDownload, const void *clientInfo)
 {
-    GRefPtr<WebKitDownload> download = webkitWebContextGetOrCreateDownload(wkDownload);
+    GRefPtr<WebKitDownload> download = webkitWebContextGetOrCreateDownload(toImpl(wkDownload));
     webkitDownloadFinished(download.get());
-    webkitWebContextRemoveDownload(wkDownload);
+    webkitWebContextRemoveDownload(toImpl(wkDownload));
 }
 
 void attachDownloadClientToContext(WebKitWebContext* webContext)
@@ -110,6 +110,6 @@ void attachDownloadClientToContext(WebKitWebContext* webContext)
         didCancel,
         0, // processDidCrash
     };
-    WKContextSetDownloadClient(webkitWebContextGetWKContext(webContext), &wkDownloadClient);
+    WKContextSetDownloadClient(toAPI(webkitWebContextGetContext(webContext)), &wkDownloadClient);
 }
 
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitFaviconDatabase.cpp b/Source/WebKit2/UIProcess/API/gtk/WebKitFaviconDatabase.cpp
new file mode 100644
index 000000000..dc320bb77
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitFaviconDatabase.cpp
@@ -0,0 +1,395 @@
+/*
+ * Copyright (C) 2012 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 "WebKitFaviconDatabase.h"
+
+#include "WebKitFaviconDatabasePrivate.h"
+#include "WebKitPrivate.h"
+#include <WebCore/FileSystem.h>
+#include <WebCore/Image.h>
+#include <WebCore/IntSize.h>
+#include <WebCore/RefPtrCairo.h>
+#include <glib/gi18n-lib.h>
+#include <wtf/MainThread.h>
+#include <wtf/gobject/GOwnPtr.h>
+#include <wtf/gobject/GRefPtr.h>
+#include <wtf/text/CString.h>
+
+using namespace WebKit;
+
+enum {
+    ICON_READY,
+
+    LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0, };
+
+typedef Vector<GRefPtr<GSimpleAsyncResult> > PendingIconRequestVector;
+typedef HashMap<String, PendingIconRequestVector*> PendingIconRequestMap;
+
+struct _WebKitFaviconDatabasePrivate {
+    RefPtr<WebIconDatabase> iconDatabase;
+    PendingIconRequestMap pendingIconRequests;
+};
+
+G_DEFINE_TYPE(WebKitFaviconDatabase, webkit_favicon_database, G_TYPE_OBJECT)
+
+static void webkit_favicon_database_init(WebKitFaviconDatabase* manager)
+{
+    WebKitFaviconDatabasePrivate* priv = G_TYPE_INSTANCE_GET_PRIVATE(manager, WEBKIT_TYPE_FAVICON_DATABASE, WebKitFaviconDatabasePrivate);
+    manager->priv = priv;
+    new (priv) WebKitFaviconDatabasePrivate();
+}
+
+static void webkitFaviconDatabaseDispose(GObject* object)
+{
+    WebKitFaviconDatabase* database = WEBKIT_FAVICON_DATABASE(object);
+
+    WebKitFaviconDatabasePrivate* priv = database->priv;
+    if (priv->iconDatabase->isOpen())
+        priv->iconDatabase->close();
+
+    G_OBJECT_CLASS(webkit_favicon_database_parent_class)->dispose(object);
+}
+
+static void webkitFaviconDatabaseFinalize(GObject* object)
+{
+    WebKitFaviconDatabase* database = WEBKIT_FAVICON_DATABASE(object);
+    database->priv->~WebKitFaviconDatabasePrivate();
+    G_OBJECT_CLASS(webkit_favicon_database_parent_class)->finalize(object);
+}
+
+static void webkit_favicon_database_class_init(WebKitFaviconDatabaseClass* faviconDatabaseClass)
+{
+    GObjectClass* gObjectClass = G_OBJECT_CLASS(faviconDatabaseClass);
+    gObjectClass->dispose = webkitFaviconDatabaseDispose;
+    gObjectClass->finalize = webkitFaviconDatabaseFinalize;
+
+    /**
+     * WebKitFaviconDatabase::favicon-ready:
+     * @database: the object on which the signal is emitted
+     * @page_uri: the URI of the Web page containing the icon.
+     *
+     * This signal gets emitted when the favicon of @page_uri is
+     * ready. This means that the favicon's data is ready to be used
+     * by the application, either because it has been loaded from the
+     * network, if it's the first time it gets retrieved, or because
+     * it has been already imported from the icon database.
+     */
+    signals[ICON_READY] =
+        g_signal_new("favicon-ready",
+                     G_TYPE_FROM_CLASS(faviconDatabaseClass),
+                     G_SIGNAL_RUN_LAST,
+                     0, 0, 0,
+                     g_cclosure_marshal_VOID__STRING,
+                     G_TYPE_NONE, 1,
+                     G_TYPE_STRING);
+
+    g_type_class_add_private(faviconDatabaseClass, sizeof(WebKitFaviconDatabasePrivate));
+}
+
+struct GetFaviconSurfaceAsyncData {
+    ~GetFaviconSurfaceAsyncData()
+    {
+        if (shouldReleaseIconForPageURL)
+            faviconDatabase->priv->iconDatabase->releaseIconForPageURL(pageURL);
+    }
+
+    GRefPtr<WebKitFaviconDatabase> faviconDatabase;
+    String pageURL;
+    RefPtr<cairo_surface_t> icon;
+    GRefPtr<GCancellable> cancellable;
+    bool shouldReleaseIconForPageURL;
+};
+WEBKIT_DEFINE_ASYNC_DATA_STRUCT(GetFaviconSurfaceAsyncData)
+
+static cairo_surface_t* getIconSurfaceSynchronously(WebKitFaviconDatabase* database, const String& pageURL, GError** error)
+{
+    ASSERT(isMainThread());
+
+    // The exact size we pass is irrelevant to the iconDatabase code.
+    // We must pass something greater than 0x0 to get an icon.
+    WebCore::Image* iconImage = database->priv->iconDatabase->imageForPageURL(pageURL, WebCore::IntSize(1, 1));
+    if (!iconImage) {
+        g_set_error(error, WEBKIT_FAVICON_DATABASE_ERROR, WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_UNKNOWN, _("Unknown favicon for page %s"), pageURL.utf8().data());
+        return 0;
+    }
+
+    WebCore::NativeImagePtr icon = iconImage->nativeImageForCurrentFrame();
+    if (!icon) {
+        g_set_error(error, WEBKIT_FAVICON_DATABASE_ERROR, WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_NOT_FOUND, _("Page %s does not have a favicon"), pageURL.utf8().data());
+        return 0;
+    }
+
+    return icon->surface();
+}
+
+static void deletePendingIconRequests(WebKitFaviconDatabase* database, PendingIconRequestVector* requests, const String& pageURL)
+{
+    database->priv->pendingIconRequests.remove(pageURL);
+    delete requests;
+}
+
+static void processPendingIconsForPageURL(WebKitFaviconDatabase* database, const String& pageURL)
+{
+    PendingIconRequestVector* pendingIconRequests = database->priv->pendingIconRequests.get(pageURL);
+    if (!pendingIconRequests)
+        return;
+
+    GOwnPtr<GError> error;
+    RefPtr<cairo_surface_t> icon = getIconSurfaceSynchronously(database, pageURL, &error.outPtr());
+
+    for (size_t i = 0; i < pendingIconRequests->size(); ++i) {
+        GSimpleAsyncResult* result = pendingIconRequests->at(i).get();
+        GetFaviconSurfaceAsyncData* data = static_cast<GetFaviconSurfaceAsyncData*>(g_simple_async_result_get_op_res_gpointer(result));
+        if (!g_cancellable_is_cancelled(data->cancellable.get())) {
+            if (error)
+                g_simple_async_result_take_error(result, error.release());
+            else {
+                data->icon = icon;
+                data->shouldReleaseIconForPageURL = false;
+            }
+        }
+
+        g_simple_async_result_complete(result);
+    }
+    deletePendingIconRequests(database, pendingIconRequests, pageURL);
+}
+
+static void iconDataReadyForPageURLCallback(WKIconDatabaseRef wkIconDatabase, WKURLRef wkPageURL, const void* clientInfo)
+{
+    ASSERT(isMainThread());
+
+    WebKitFaviconDatabase* database = WEBKIT_FAVICON_DATABASE(clientInfo);
+    String pageURL = toImpl(wkPageURL)->string();
+
+    processPendingIconsForPageURL(database, pageURL);
+    g_signal_emit(database, signals[ICON_READY], 0, pageURL.utf8().data());
+}
+
+WebKitFaviconDatabase* webkitFaviconDatabaseCreate(WebIconDatabase* iconDatabase)
+{
+    WebKitFaviconDatabase* faviconDatabase = WEBKIT_FAVICON_DATABASE(g_object_new(WEBKIT_TYPE_FAVICON_DATABASE, NULL));
+    faviconDatabase->priv->iconDatabase = iconDatabase;
+
+    WKIconDatabaseClient wkIconDatabaseClient = {
+        kWKIconDatabaseClientCurrentVersion,
+        faviconDatabase, // clientInfo
+        0, // didChangeIconForPageURLCallback
+        0, // didRemoveAllIconsCallback
+        iconDataReadyForPageURLCallback,
+    };
+    WKIconDatabaseSetIconDatabaseClient(toAPI(iconDatabase), &wkIconDatabaseClient);
+    return faviconDatabase;
+}
+
+cairo_surface_t* webkitFaviconDatabaseGetFavicon(WebKitFaviconDatabase* database, const CString& pageURL)
+{
+    ASSERT(WEBKIT_IS_FAVICON_DATABASE(database));
+    ASSERT(!pageURL.isNull());
+
+    cairo_surface_t* iconSurface = getIconSurfaceSynchronously(database, String::fromUTF8(pageURL.data()), 0);
+    if (!iconSurface)
+        return 0;
+
+    return cairo_surface_reference(iconSurface);
+}
+
+static PendingIconRequestVector* getOrCreatePendingIconRequests(WebKitFaviconDatabase* database, const String& pageURL)
+{
+    PendingIconRequestVector* icons = database->priv->pendingIconRequests.get(pageURL);
+    if (!icons) {
+        icons = new PendingIconRequestVector;
+        database->priv->pendingIconRequests.set(pageURL, icons);
+    }
+
+    return icons;
+}
+
+static void setErrorForAsyncResult(GSimpleAsyncResult* result, WebKitFaviconDatabaseError error, const String& pageURL = String())
+{
+    ASSERT(result);
+
+    switch (error) {
+    case WEBKIT_FAVICON_DATABASE_ERROR_NOT_INITIALIZED:
+        g_simple_async_result_set_error(result, WEBKIT_FAVICON_DATABASE_ERROR, error, _("Favicons database not initialized yet"));
+        break;
+
+    case WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_NOT_FOUND:
+        g_simple_async_result_set_error(result, WEBKIT_FAVICON_DATABASE_ERROR, error, _("Page %s does not have a favicon"), pageURL.utf8().data());
+        break;
+
+    case WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_UNKNOWN:
+        g_simple_async_result_set_error(result, WEBKIT_FAVICON_DATABASE_ERROR, error, _("Unknown favicon for page %s"), pageURL.utf8().data());
+        break;
+
+    default:
+        ASSERT_NOT_REACHED();
+    }
+}
+
+GQuark webkit_favicon_database_error_quark(void)
+{
+    return g_quark_from_static_string("WebKitFaviconDatabaseError");
+}
+
+/**
+ * webkit_favicon_database_get_favicon:
+ * @database: a #WebKitFaviconDatabase
+ * @page_uri: URI of the page for which we want to retrieve the favicon
+ * @cancellable: (allow-none): A #GCancellable or %NULL.
+ * @callback: (scope async): A #GAsyncReadyCallback to call when the request is
+ *            satisfied or %NULL if you don't care about the result.
+ * @user_data: (closure): The data to pass to @callback.
+ *
+ * Asynchronously obtains a #cairo_surface_t of the favicon for the
+ * given page URI. It returns the cached icon if it's in the database
+ * asynchronously waiting for the icon to be read from the database.
+ *
+ * This is an asynchronous method. When the operation is finished, callback will
+ * be invoked. You can then call webkit_favicon_database_get_favicon_finish()
+ * to get the result of the operation.
+ */
+void webkit_favicon_database_get_favicon(WebKitFaviconDatabase* database, const gchar* pageURI, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
+{
+    g_return_if_fail(WEBKIT_IS_FAVICON_DATABASE(database));
+    g_return_if_fail(pageURI);
+
+    GRefPtr<GSimpleAsyncResult> result = adoptGRef(g_simple_async_result_new(G_OBJECT(database), callback, userData, reinterpret_cast<gpointer>(webkit_favicon_database_get_favicon)));
+    g_simple_async_result_set_check_cancellable(result.get(), cancellable);
+
+    GetFaviconSurfaceAsyncData* data = createGetFaviconSurfaceAsyncData();
+    g_simple_async_result_set_op_res_gpointer(result.get(), data, reinterpret_cast<GDestroyNotify>(destroyGetFaviconSurfaceAsyncData));
+    data->faviconDatabase = database;
+    data->pageURL = String::fromUTF8(pageURI);
+    data->cancellable = cancellable;
+
+    WebKitFaviconDatabasePrivate* priv = database->priv;
+    WebIconDatabase* iconDatabaseImpl = priv->iconDatabase.get();
+    if (!iconDatabaseImpl->isOpen()) {
+        setErrorForAsyncResult(result.get(), WEBKIT_FAVICON_DATABASE_ERROR_NOT_INITIALIZED);
+        g_simple_async_result_complete_in_idle(result.get());
+        return;
+    }
+
+    if (data->pageURL.isEmpty() || data->pageURL.startsWith("about:")) {
+        setErrorForAsyncResult(result.get(), WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_NOT_FOUND, data->pageURL);
+        g_simple_async_result_complete_in_idle(result.get());
+        return;
+    }
+
+    priv->iconDatabase->retainIconForPageURL(data->pageURL);
+
+    // We ask for the icon directly. If we don't get the icon data now,
+    // we'll be notified later (even if the database is still importing icons).
+    GOwnPtr<GError> error;
+    data->icon = getIconSurfaceSynchronously(database, data->pageURL, &error.outPtr());
+    if (data->icon) {
+        g_simple_async_result_complete_in_idle(result.get());
+        return;
+    }
+
+    // At this point we still don't know whether we will get a valid icon for pageURL.
+    data->shouldReleaseIconForPageURL = true;
+
+    if (g_error_matches(error.get(), WEBKIT_FAVICON_DATABASE_ERROR, WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_NOT_FOUND)) {
+        g_simple_async_result_take_error(result.get(), error.release());
+        g_simple_async_result_complete_in_idle(result.get());
+        return;
+    }
+
+    // If there's not a valid icon, but there's an iconURL registered,
+    // or it's still not registered but the import process hasn't
+    // finished yet, we need to wait for iconDataReadyForPage to be
+    // called before making and informed decision.
+    String iconURLForPageURL;
+    iconDatabaseImpl->synchronousIconURLForPageURL(data->pageURL, iconURLForPageURL);
+    if (!iconURLForPageURL.isEmpty() || !iconDatabaseImpl->isUrlImportCompleted()) {
+        PendingIconRequestVector* icons = getOrCreatePendingIconRequests(database, data->pageURL);
+        ASSERT(icons);
+        icons->append(result);
+        return;
+    }
+
+    setErrorForAsyncResult(result.get(), WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_UNKNOWN, data->pageURL);
+    g_simple_async_result_complete_in_idle(result.get());
+}
+
+/**
+ * webkit_favicon_database_get_favicon_finish:
+ * @database: a #WebKitFaviconDatabase
+ * @result: A #GAsyncResult obtained from the #GAsyncReadyCallback passed to webkit_favicon_database_get_favicon()
+ * @error: (allow-none): Return location for error or %NULL.
+ *
+ * Finishes an operation started with webkit_favicon_database_get_favicon().
+ *
+ * Returns: (transfer full): a new reference to a #cairo_surface_t, or
+ * %NULL in case of error.
+ */
+cairo_surface_t* webkit_favicon_database_get_favicon_finish(WebKitFaviconDatabase* database, GAsyncResult* result, GError** error)
+{
+    GSimpleAsyncResult* simpleResult = G_SIMPLE_ASYNC_RESULT(result);
+    g_warn_if_fail(g_simple_async_result_get_source_tag(simpleResult) == webkit_favicon_database_get_favicon);
+
+    if (g_simple_async_result_propagate_error(simpleResult, error))
+        return 0;
+
+    GetFaviconSurfaceAsyncData* data = static_cast<GetFaviconSurfaceAsyncData*>(g_simple_async_result_get_op_res_gpointer(simpleResult));
+    ASSERT(data);
+    return cairo_surface_reference(data->icon.get());
+}
+
+/**
+ * webkit_favicon_database_get_favicon_uri:
+ * @database: a #WebKitFaviconDatabase
+ * @page_uri: URI of the page containing the icon
+ *
+ * Obtains the URI of the favicon for the given @page_uri.
+ *
+ * Returns: a newly allocated URI for the favicon, or %NULL if the
+ * database doesn't have a favicon for @page_uri.
+ */
+gchar* webkit_favicon_database_get_favicon_uri(WebKitFaviconDatabase* database, const gchar* pageURL)
+{
+    g_return_val_if_fail(WEBKIT_IS_FAVICON_DATABASE(database), 0);
+    g_return_val_if_fail(pageURL, 0);
+    ASSERT(isMainThread());
+
+    String iconURLForPageURL;
+    database->priv->iconDatabase->synchronousIconURLForPageURL(String::fromUTF8(pageURL), iconURLForPageURL);
+    if (iconURLForPageURL.isEmpty())
+        return 0;
+
+    return g_strdup(iconURLForPageURL.utf8().data());
+}
+
+/**
+ * webkit_favicon_database_clear:
+ * @database: a #WebKitFaviconDatabase
+ *
+ * Clears all icons from the database.
+ */
+void webkit_favicon_database_clear(WebKitFaviconDatabase* database)
+{
+    g_return_if_fail(WEBKIT_IS_FAVICON_DATABASE(database));
+
+    database->priv->iconDatabase->removeAllIcons();
+}
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitFaviconDatabase.h b/Source/WebKit2/UIProcess/API/gtk/WebKitFaviconDatabase.h
new file mode 100644
index 000000000..811a8e6bb
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitFaviconDatabase.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2012 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.
+ */
+
+#if !defined(__WEBKIT2_H_INSIDE__) && !defined(WEBKIT2_COMPILATION)
+#error "Only <webkit2/webkit2.h> can be included directly."
+#endif
+
+#ifndef WebKitFaviconDatabase_h
+#define WebKitFaviconDatabase_h
+
+#include <cairo.h>
+#include <gio/gio.h>
+#include <glib-object.h>
+#include <webkit2/WebKitDefines.h>
+
+G_BEGIN_DECLS
+
+#define WEBKIT_TYPE_FAVICON_DATABASE            (webkit_favicon_database_get_type())
+#define WEBKIT_FAVICON_DATABASE(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), WEBKIT_TYPE_FAVICON_DATABASE, WebKitFaviconDatabase))
+#define WEBKIT_IS_FAVICON_DATABASE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), WEBKIT_TYPE_FAVICON_DATABASE))
+#define WEBKIT_FAVICON_DATABASE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass),  WEBKIT_TYPE_FAVICON_DATABASE, WebKitFaviconDatabaseClass))
+#define WEBKIT_IS_FAVICON_DATABASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),  WEBKIT_TYPE_FAVICON_DATABASE))
+#define WEBKIT_FAVICON_DATABASE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj),  WEBKIT_TYPE_FAVICON_DATABASE, WebKitFaviconDatabaseClass))
+#define WEBKIT_FAVICON_DATABASE_ERROR           (webkit_favicon_database_error_quark())
+
+typedef struct _WebKitFaviconDatabase        WebKitFaviconDatabase;
+typedef struct _WebKitFaviconDatabaseClass   WebKitFaviconDatabaseClass;
+typedef struct _WebKitFaviconDatabasePrivate WebKitFaviconDatabasePrivate;
+
+struct _WebKitFaviconDatabase {
+    GObject parent;
+
+    WebKitFaviconDatabasePrivate *priv;
+};
+
+struct _WebKitFaviconDatabaseClass {
+    GObjectClass parent_class;
+};
+
+/**
+ * WebKitFaviconDatabaseError:
+ * @WEBKIT_FAVICON_DATABASE_ERROR_NOT_INITIALIZED: The #WebKitFaviconDatabase has not been initialized yet
+ * @WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_NOT_FOUND: There is not an icon available for the requested URL
+ * @WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_UNKNOWN: There might be an icon for the requested URL, but its data is unknown at the moment
+ *
+ * Enum values used to denote the various errors related to the #WebKitFaviconDatabase.
+ **/
+typedef enum {
+    WEBKIT_FAVICON_DATABASE_ERROR_NOT_INITIALIZED,
+    WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_NOT_FOUND,
+    WEBKIT_FAVICON_DATABASE_ERROR_FAVICON_UNKNOWN
+} WebKitFaviconDatabaseError;
+
+WEBKIT_API GQuark
+webkit_favicon_database_error_quark        (void);
+
+WEBKIT_API GType
+webkit_favicon_database_get_type           (void);
+
+WEBKIT_API void
+webkit_favicon_database_get_favicon        (WebKitFaviconDatabase *database,
+                                            const gchar           *page_uri,
+                                            GCancellable          *cancellable,
+                                            GAsyncReadyCallback    callback,
+                                            gpointer               user_data);
+WEBKIT_API cairo_surface_t *
+webkit_favicon_database_get_favicon_finish (WebKitFaviconDatabase *database,
+                                            GAsyncResult          *result,
+                                            GError               **error);
+WEBKIT_API gchar *
+webkit_favicon_database_get_favicon_uri    (WebKitFaviconDatabase *database,
+                                            const gchar           *page_uri);
+WEBKIT_API void
+webkit_favicon_database_clear              (WebKitFaviconDatabase *database);
+
+G_END_DECLS
+
+#endif
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitFaviconDatabasePrivate.h b/Source/WebKit2/UIProcess/API/gtk/WebKitFaviconDatabasePrivate.h
new file mode 100644
index 000000000..6c50949fb
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitFaviconDatabasePrivate.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 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.
+ */
+
+#ifndef WebKitFaviconDatabasePrivate_h
+#define WebKitFaviconDatabasePrivate_h
+
+#include "WebIconDatabase.h"
+#include "WebKitFaviconDatabase.h"
+#include <wtf/text/CString.h>
+
+using namespace WebKit;
+
+WebKitFaviconDatabase* webkitFaviconDatabaseCreate(WebIconDatabase*);
+cairo_surface_t* webkitFaviconDatabaseGetFavicon(WebKitFaviconDatabase*, const CString&);
+
+#endif // WebKitFaviconDatabasePrivate_h
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitJavascriptResult.cpp b/Source/WebKit2/UIProcess/API/gtk/WebKitJavascriptResult.cpp
index 84ad04d03..2a1b8d5a3 100644
--- a/Source/WebKit2/UIProcess/API/gtk/WebKitJavascriptResult.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitJavascriptResult.cpp
@@ -21,15 +21,16 @@
 #include "WebKitJavascriptResult.h"
 
 #include "WebKitJavascriptResultPrivate.h"
+#include "WebSerializedScriptValue.h"
 #include <wtf/gobject/GRefPtr.h>
 
 struct _WebKitJavascriptResult {
-    _WebKitJavascriptResult(WebKitWebView* view, WKSerializedScriptValueRef wkSerializedScriptValue)
+    _WebKitJavascriptResult(WebKitWebView* view, WebSerializedScriptValue* serializedScriptValue)
         : webView(view)
         , referenceCount(1)
-        {
-            value = WKSerializedScriptValueDeserialize(wkSerializedScriptValue, webkit_web_view_get_javascript_global_context(view), 0);
-        }
+    {
+        value = serializedScriptValue->deserialize(webkit_web_view_get_javascript_global_context(view), 0);
+    }
 
     GRefPtr<WebKitWebView> webView;
     JSValueRef value;
@@ -39,10 +40,10 @@ struct _WebKitJavascriptResult {
 
 G_DEFINE_BOXED_TYPE(WebKitJavascriptResult, webkit_javascript_result, webkit_javascript_result_ref, webkit_javascript_result_unref)
 
-WebKitJavascriptResult* webkitJavascriptResultCreate(WebKitWebView* webView, WKSerializedScriptValueRef wkSerializedScriptValue)
+WebKitJavascriptResult* webkitJavascriptResultCreate(WebKitWebView* webView, WebSerializedScriptValue* serializedScriptValue)
 {
     WebKitJavascriptResult* result = g_slice_new(WebKitJavascriptResult);
-    new (result) WebKitJavascriptResult(webView, wkSerializedScriptValue);
+    new (result) WebKitJavascriptResult(webView, serializedScriptValue);
     return result;
 }
 
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitJavascriptResultPrivate.h b/Source/WebKit2/UIProcess/API/gtk/WebKitJavascriptResultPrivate.h
index 840ead058..ac7578857 100644
--- a/Source/WebKit2/UIProcess/API/gtk/WebKitJavascriptResultPrivate.h
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitJavascriptResultPrivate.h
@@ -24,6 +24,8 @@
 #include "WebKitPrivate.h"
 #include "WebKitWebView.h"
 
-WebKitJavascriptResult* webkitJavascriptResultCreate(WebKitWebView*, WKSerializedScriptValueRef);
+using namespace WebKit;
+
+WebKitJavascriptResult* webkitJavascriptResultCreate(WebKitWebView*, WebSerializedScriptValue*);
 
 #endif // WebKitJavascriptResultPrivate_h
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitLoaderClient.cpp b/Source/WebKit2/UIProcess/API/gtk/WebKitLoaderClient.cpp
index 6c3bf920a..457c40141 100644
--- a/Source/WebKit2/UIProcess/API/gtk/WebKitLoaderClient.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitLoaderClient.cpp
@@ -152,6 +152,7 @@ void attachLoaderClientToView(WebKitWebView* webView)
         0, // pluginDidFail
         0, // didReceiveIntentForFrame
         0, // registerIntentServiceForFrame
+        0, // didLayout
     };
     WKPageRef wkPage = toAPI(webkitWebViewBaseGetPage(WEBKIT_WEB_VIEW_BASE(webView)));
     WKPageSetPageLoaderClient(wkPage, &wkLoaderClient);
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitPrivate.h b/Source/WebKit2/UIProcess/API/gtk/WebKitPrivate.h
index 8fede827f..9ceafecb6 100644
--- a/Source/WebKit2/UIProcess/API/gtk/WebKitPrivate.h
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitPrivate.h
@@ -34,6 +34,7 @@
 #include <WebKit2/WKGeolocationManager.h>
 #include <WebKit2/WKGeolocationPermissionRequest.h>
 #include <WebKit2/WKGeolocationPosition.h>
+#include <WebKit2/WKIconDatabase.h>
 #include <WebKit2/WKInspector.h>
 #include <WebKit2/WKInspectorClientGtk.h>
 #include <WebKit2/WKRetainPtr.h>
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitRequestManagerClient.cpp b/Source/WebKit2/UIProcess/API/gtk/WebKitRequestManagerClient.cpp
index 8ea09f200..babafe651 100644
--- a/Source/WebKit2/UIProcess/API/gtk/WebKitRequestManagerClient.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitRequestManagerClient.cpp
@@ -26,10 +26,10 @@
 
 using namespace WebKit;
 
-static void didReceiveURIRequest(WKSoupRequestManagerRef soupRequestManagerRef, WKURLRef urlRef, uint64_t requestID, const void* clientInfo)
+static void didReceiveURIRequest(WKSoupRequestManagerRef soupRequestManagerRef, WKURLRef urlRef, WKPageRef initiatingPageRef, uint64_t requestID, const void* clientInfo)
 {
     WebKitWebContext* webContext = WEBKIT_WEB_CONTEXT(clientInfo);
-    GRefPtr<WebKitURISchemeRequest> request = adoptGRef(webkitURISchemeRequestCreate(webContext, soupRequestManagerRef, urlRef, requestID));
+    GRefPtr<WebKitURISchemeRequest> request = adoptGRef(webkitURISchemeRequestCreate(webContext, soupRequestManagerRef, urlRef, initiatingPageRef, requestID));
     webkitWebContextReceivedURIRequest(webContext, request.get());
 }
 
@@ -46,6 +46,6 @@ void attachRequestManagerClientToContext(WebKitWebContext* webContext)
         didReceiveURIRequest,
         didFailToLoadURIRequest
     };
-    WKSoupRequestManagerSetClient(webkitWebContextGetRequestManager(webContext), &wkRequestManagerClient);
+    WKSoupRequestManagerSetClient(toAPI(webkitWebContextGetRequestManager(webContext)), &wkRequestManagerClient);
 }
 
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitSecurityManager.cpp b/Source/WebKit2/UIProcess/API/gtk/WebKitSecurityManager.cpp
index 53b46f875..d170fcf3f 100644
--- a/Source/WebKit2/UIProcess/API/gtk/WebKitSecurityManager.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitSecurityManager.cpp
@@ -74,7 +74,7 @@ WebKitSecurityManager* webkitSecurityManagerCreate(WebKitWebContext* webContext)
 static void registerSecurityPolicyForURIScheme(WebKitSecurityManager* manager, const char* scheme, SecurityPolicy policy)
 {
     String urlScheme = String::fromUTF8(scheme);
-    WebContext* webContext = toImpl(webkitWebContextGetWKContext(manager->priv->webContext));
+    WebContext* webContext = webkitWebContextGetContext(manager->priv->webContext);
 
     // We keep the WebCore::SchemeRegistry of the UI process in sync with the
     // web process one, so that we can return the SecurityPolicy for
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp b/Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp
index c0a64162a..17d4c881b 100644
--- a/Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitSettings.cpp
@@ -34,6 +34,7 @@
 #include "WebKitPrivate.h"
 #include "WebKitSettingsPrivate.h"
 #include "WebPageProxy.h"
+#include "WebPreferences.h"
 #include <WebCore/UserAgentGtk.h>
 #include <glib/gi18n-lib.h>
 #include <wtf/text/CString.h>
@@ -117,7 +118,8 @@ enum {
     PROP_DRAW_COMPOSITING_INDICATORS,
     PROP_ENABLE_SITE_SPECIFIC_QUIRKS,
     PROP_ENABLE_PAGE_CACHE,
-    PROP_USER_AGENT
+    PROP_USER_AGENT,
+    PROP_ENABLE_SMOOTH_SCROLLING
 };
 
 static void webKitSettingsSetProperty(GObject* object, guint propId, const GValue* value, GParamSpec* paramSpec)
@@ -251,6 +253,9 @@ static void webKitSettingsSetProperty(GObject* object, guint propId, const GValu
     case PROP_USER_AGENT:
         webkit_settings_set_user_agent(settings, g_value_get_string(value));
         break;
+    case PROP_ENABLE_SMOOTH_SCROLLING:
+        webkit_settings_set_enable_smooth_scrolling(settings, g_value_get_boolean(value));
+        break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, paramSpec);
         break;
@@ -388,6 +393,9 @@ static void webKitSettingsGetProperty(GObject* object, guint propId, GValue* val
     case PROP_USER_AGENT:
         g_value_set_string(value, webkit_settings_get_user_agent(settings));
         break;
+    case PROP_ENABLE_SMOOTH_SCROLLING:
+        g_value_set_boolean(value, webkit_settings_get_enable_smooth_scrolling(settings));
+        break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, paramSpec);
         break;
@@ -1039,6 +1047,19 @@ static void webkit_settings_class_init(WebKitSettingsClass* klass)
                                                         0, // A null string forces the standard user agent.
                                                         readWriteConstructParamFlags));
 
+    /**
+     * WebKitSettings:enable-smooth-scrolling:
+     *
+     * Enable or disable smooth scrolling.
+     */
+    g_object_class_install_property(gObjectClass,
+                                    PROP_ENABLE_SMOOTH_SCROLLING,
+                                    g_param_spec_boolean("enable-smooth-scrolling",
+                                                         _("Enable smooth scrolling"),
+                                                         _("Whether to enable smooth scrolling"),
+                                                         FALSE,
+                                                         readWriteConstructParamFlags));
+
     g_type_class_add_private(klass, sizeof(WebKitSettingsPrivate));
 }
 
@@ -2644,3 +2665,38 @@ void webkit_settings_set_user_agent_with_application_details(WebKitSettings* set
     CString newUserAgent = WebCore::standardUserAgent(String::fromUTF8(applicationName), String::fromUTF8(applicationVersion)).utf8();
     webkit_settings_set_user_agent(settings, newUserAgent.data());
 }
+
+/**
+ * webkit_settings_get_enable_smooth_scrolling:
+ * @settings: a #WebKitSettings
+ *
+ * Get the #WebKitSettings:enable-smooth-scrolling property.
+ *
+ * Returns: %TRUE if smooth scrolling is enabled or %FALSE otherwise.
+ */
+gboolean webkit_settings_get_enable_smooth_scrolling(WebKitSettings* settings)
+{
+    g_return_val_if_fail(WEBKIT_IS_SETTINGS(settings), FALSE);
+
+    return WebKit::toImpl(settings->priv->preferences.get())->scrollAnimatorEnabled();
+}
+
+/**
+ * webkit_settings_set_enable_smooth_scrolling:
+ * @settings: a #WebKitSettings
+ * @enabled: Value to be set
+ *
+ * Set the #WebKitSettings:enable-smooth-scrolling property.
+ */
+void webkit_settings_set_enable_smooth_scrolling(WebKitSettings* settings, gboolean enabled)
+{
+    g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
+
+    WebKitSettingsPrivate* priv = settings->priv;
+    bool currentValue = WebKit::toImpl(priv->preferences.get())->scrollAnimatorEnabled();
+    if (currentValue == enabled)
+        return;
+
+    WebKit::toImpl(priv->preferences.get())->setScrollAnimatorEnabled(enabled);
+    g_object_notify(G_OBJECT(settings), "enable-smooth-scrolling");
+}
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitSettings.h b/Source/WebKit2/UIProcess/API/gtk/WebKitSettings.h
index b35a23f06..a9fe86a30 100644
--- a/Source/WebKit2/UIProcess/API/gtk/WebKitSettings.h
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitSettings.h
@@ -373,6 +373,13 @@ webkit_settings_set_user_agent_with_application_details        (WebKitSettings *
                                                                 const gchar    *application_name,
                                                                 const gchar    *application_version);
 
+WEBKIT_API gboolean
+webkit_settings_get_enable_smooth_scrolling                    (WebKitSettings *settings);
+
+WEBKIT_API void
+webkit_settings_set_enable_smooth_scrolling                    (WebKitSettings *settings,
+                                                                gboolean        enabled);
+
 G_END_DECLS
 
 #endif /* WebKitSettings_h */
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitURISchemeRequest.cpp b/Source/WebKit2/UIProcess/API/gtk/WebKitURISchemeRequest.cpp
index e62c1faf5..e69831f29 100644
--- a/Source/WebKit2/UIProcess/API/gtk/WebKitURISchemeRequest.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitURISchemeRequest.cpp
@@ -22,6 +22,8 @@
 
 #include "WebKitURISchemeRequestPrivate.h"
 #include "WebKitWebContextPrivate.h"
+#include "WebKitWebView.h"
+#include "WebPageProxy.h"
 #include <WebCore/GOwnPtrSoup.h>
 #include <libsoup/soup.h>
 #include <wtf/gobject/GRefPtr.h>
@@ -36,6 +38,7 @@ G_DEFINE_TYPE(WebKitURISchemeRequest, webkit_uri_scheme_request, G_TYPE_OBJECT)
 struct _WebKitURISchemeRequestPrivate {
     WebKitWebContext* webContext;
     WKRetainPtr<WKSoupRequestManagerRef> wkRequestManager;
+    WKRetainPtr<WKPageRef> wkInitiatingPage;
     uint64_t requestID;
     CString uri;
     GOwnPtr<SoupURI> soupURI;
@@ -68,12 +71,13 @@ static void webkit_uri_scheme_request_class_init(WebKitURISchemeRequestClass* re
     g_type_class_add_private(requestClass, sizeof(WebKitURISchemeRequestPrivate));
 }
 
-WebKitURISchemeRequest* webkitURISchemeRequestCreate(WebKitWebContext* webContext, WKSoupRequestManagerRef wkRequestManager, WKURLRef wkURL, uint64_t requestID)
+WebKitURISchemeRequest* webkitURISchemeRequestCreate(WebKitWebContext* webContext, WKSoupRequestManagerRef wkRequestManager, WKURLRef wkURL, WKPageRef wkInitiatingPage, uint64_t requestID)
 {
     WebKitURISchemeRequest* request = WEBKIT_URI_SCHEME_REQUEST(g_object_new(WEBKIT_TYPE_URI_SCHEME_REQUEST, NULL));
     request->priv->webContext = webContext;
     request->priv->wkRequestManager = wkRequestManager;
     request->priv->uri = toImpl(wkURL)->string().utf8();
+    request->priv->wkInitiatingPage = wkInitiatingPage;
     request->priv->requestID = requestID;
     return request;
 }
@@ -138,6 +142,21 @@ const char* webkit_uri_scheme_request_get_path(WebKitURISchemeRequest* request)
     return request->priv->soupURI->path;
 }
 
+/**
+ * webkit_uri_scheme_request_get_web_view:
+ * @request: a #WebKitURISchemeRequest
+ *
+ * Get the #WebKitWebView that initiated the request.
+ *
+ * Returns: (transfer none): the #WebKitWebView that initiated @request.
+ */
+WebKitWebView* webkit_uri_scheme_request_get_web_view(WebKitURISchemeRequest* request)
+{
+    g_return_val_if_fail(WEBKIT_IS_URI_SCHEME_REQUEST(request), 0);
+
+    return WEBKIT_WEB_VIEW(toImpl(request->priv->wkInitiatingPage.get())->viewWidget());
+}
+
 static void webkitURISchemeRequestReadCallback(GInputStream* inputStream, GAsyncResult* result, WebKitURISchemeRequest* schemeRequest)
 {
     GRefPtr<WebKitURISchemeRequest> request = adoptGRef(schemeRequest);
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitURISchemeRequest.h b/Source/WebKit2/UIProcess/API/gtk/WebKitURISchemeRequest.h
index 34f214489..9ead50709 100644
--- a/Source/WebKit2/UIProcess/API/gtk/WebKitURISchemeRequest.h
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitURISchemeRequest.h
@@ -51,22 +51,25 @@ struct _WebKitURISchemeRequestClass {
 };
 
 WEBKIT_API GType
-webkit_uri_scheme_request_get_type   (void);
+webkit_uri_scheme_request_get_type     (void);
 
 WEBKIT_API const gchar *
-webkit_uri_scheme_request_get_scheme (WebKitURISchemeRequest *request);
+webkit_uri_scheme_request_get_scheme   (WebKitURISchemeRequest *request);
 
 WEBKIT_API const gchar *
-webkit_uri_scheme_request_get_uri    (WebKitURISchemeRequest *request);
+webkit_uri_scheme_request_get_uri      (WebKitURISchemeRequest *request);
 
 WEBKIT_API const gchar *
-webkit_uri_scheme_request_get_path   (WebKitURISchemeRequest *request);
+webkit_uri_scheme_request_get_path     (WebKitURISchemeRequest *request);
+
+WEBKIT_API WebKitWebView *
+webkit_uri_scheme_request_get_web_view (WebKitURISchemeRequest *request);
 
 WEBKIT_API void
-webkit_uri_scheme_request_finish     (WebKitURISchemeRequest *request,
-                                      GInputStream           *stream,
-                                      gint64                  stream_length,
-                                      const gchar            *mime_type);
+webkit_uri_scheme_request_finish       (WebKitURISchemeRequest *request,
+                                        GInputStream           *stream,
+                                        gint64                  stream_length,
+                                        const gchar            *mime_type);
 
 G_END_DECLS
 
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitURISchemeRequestPrivate.h b/Source/WebKit2/UIProcess/API/gtk/WebKitURISchemeRequestPrivate.h
index 149813def..b7c011f66 100644
--- a/Source/WebKit2/UIProcess/API/gtk/WebKitURISchemeRequestPrivate.h
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitURISchemeRequestPrivate.h
@@ -25,7 +25,7 @@
 #include "WebKitWebContext.h"
 #include <WebKit2/WKSoupRequestManager.h>
 
-WebKitURISchemeRequest* webkitURISchemeRequestCreate(WebKitWebContext*, WKSoupRequestManagerRef, WKURLRef, uint64_t requestID);
+WebKitURISchemeRequest* webkitURISchemeRequestCreate(WebKitWebContext*, WKSoupRequestManagerRef, WKURLRef, WKPageRef, uint64_t requestID);
 uint64_t webkitURISchemeRequestGetID(WebKitURISchemeRequest*);
 void webkitURISchemeRequestCancel(WebKitURISchemeRequest*);
 
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp b/Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp
index 5b2c26697..dab18a87d 100644
--- a/Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.cpp
@@ -20,10 +20,10 @@
 #include "config.h"
 #include "WebKitWebContext.h"
 
-#include "WebContext.h"
 #include "WebKitCookieManagerPrivate.h"
 #include "WebKitDownloadClient.h"
 #include "WebKitDownloadPrivate.h"
+#include "WebKitFaviconDatabasePrivate.h"
 #include "WebKitGeolocationProvider.h"
 #include "WebKitPluginPrivate.h"
 #include "WebKitPrivate.h"
@@ -32,7 +32,9 @@
 #include "WebKitTextChecker.h"
 #include "WebKitURISchemeRequestPrivate.h"
 #include "WebKitWebContextPrivate.h"
+#include "WebResourceCacheManagerProxy.h"
 #include <WebCore/FileSystem.h>
+#include <WebCore/IconDatabase.h>
 #include <WebCore/Language.h>
 #include <wtf/HashMap.h>
 #include <wtf/OwnPtr.h>
@@ -42,8 +44,6 @@
 #include <wtf/gobject/GRefPtr.h>
 #include <wtf/text/CString.h>
 
-using namespace WebKit;
-
 enum {
     DOWNLOAD_STARTED,
 
@@ -93,11 +93,12 @@ typedef HashMap<String, RefPtr<WebKitURISchemeHandler> > URISchemeHandlerMap;
 typedef HashMap<uint64_t, GRefPtr<WebKitURISchemeRequest> > URISchemeRequestMap;
 
 struct _WebKitWebContextPrivate {
-    WKRetainPtr<WKContextRef> context;
+    RefPtr<WebContext> context;
 
     GRefPtr<WebKitCookieManager> cookieManager;
+    GRefPtr<WebKitFaviconDatabase> faviconDatabase;
     GRefPtr<WebKitSecurityManager> securityManager;
-    WKRetainPtr<WKSoupRequestManagerRef> requestManager;
+    RefPtr<WebSoupRequestManagerProxy> requestManager;
     URISchemeHandlerMap uriSchemeHandlers;
     URISchemeRequestMap uriSchemeRequests;
 #if ENABLE(GEOLOCATION)
@@ -106,6 +107,7 @@ struct _WebKitWebContextPrivate {
 #if ENABLE(SPELLCHECK)
     OwnPtr<WebKitTextChecker> textChecker;
 #endif
+    CString faviconDatabaseDirectory;
 };
 
 static guint signals[LAST_SIGNAL] = { 0, };
@@ -152,17 +154,20 @@ static void webkit_web_context_class_init(WebKitWebContextClass* webContextClass
 static gpointer createDefaultWebContext(gpointer)
 {
     static GRefPtr<WebKitWebContext> webContext = adoptGRef(WEBKIT_WEB_CONTEXT(g_object_new(WEBKIT_TYPE_WEB_CONTEXT, NULL)));
-    webContext->priv->context = WKContextCreate();
-    webContext->priv->requestManager = WKContextGetSoupRequestManager(webContext->priv->context.get());
-    WKContextSetCacheModel(webContext->priv->context.get(), kWKCacheModelPrimaryWebBrowser);
+    WebKitWebContextPrivate* priv = webContext->priv;
+
+    priv->context = WebContext::create(String());
+    priv->requestManager = webContext->priv->context->soupRequestManagerProxy();
+    priv->context->setCacheModel(CacheModelPrimaryWebBrowser);
+
     attachDownloadClientToContext(webContext.get());
     attachRequestManagerClientToContext(webContext.get());
+
 #if ENABLE(GEOLOCATION)
-    WKGeolocationManagerRef wkGeolocationManager = WKContextGetGeolocationManager(webContext->priv->context.get());
-    webContext->priv->geolocationProvider = WebKitGeolocationProvider::create(wkGeolocationManager);
+    priv->geolocationProvider = WebKitGeolocationProvider::create(toAPI(priv->context->geolocationManagerProxy()));
 #endif
 #if ENABLE(SPELLCHECK)
-    webContext->priv->textChecker = WebKitTextChecker::create();
+    priv->textChecker = WebKitTextChecker::create();
 #endif
     return webContext.get();
 }
@@ -206,26 +211,26 @@ WebKitWebContext* webkit_web_context_get_default(void)
  */
 void webkit_web_context_set_cache_model(WebKitWebContext* context, WebKitCacheModel model)
 {
-    WKCacheModel cacheModel;
+    CacheModel cacheModel;
 
     g_return_if_fail(WEBKIT_IS_WEB_CONTEXT(context));
 
     switch (model) {
     case WEBKIT_CACHE_MODEL_DOCUMENT_VIEWER:
-        cacheModel = kWKCacheModelDocumentViewer;
+        cacheModel = CacheModelDocumentViewer;
         break;
     case WEBKIT_CACHE_MODEL_WEB_BROWSER:
-        cacheModel = kWKCacheModelPrimaryWebBrowser;
+        cacheModel = CacheModelPrimaryWebBrowser;
         break;
     case WEBKIT_CACHE_MODEL_DOCUMENT_BROWSER:
-        cacheModel = kWKCacheModelDocumentBrowser;
+        cacheModel = CacheModelDocumentBrowser;
         break;
     default:
         g_assert_not_reached();
     }
-    WebKitWebContextPrivate* priv = context->priv;
-    if (cacheModel != WKContextGetCacheModel(priv->context.get()))
-        WKContextSetCacheModel(priv->context.get(), cacheModel);
+
+    if (cacheModel != context->priv->context->cacheModel())
+        context->priv->context->setCacheModel(cacheModel);
 }
 
 /**
@@ -242,13 +247,12 @@ WebKitCacheModel webkit_web_context_get_cache_model(WebKitWebContext* context)
 {
     g_return_val_if_fail(WEBKIT_IS_WEB_CONTEXT(context), WEBKIT_CACHE_MODEL_WEB_BROWSER);
 
-    WebKitWebContextPrivate* priv = context->priv;
-    switch (WKContextGetCacheModel(priv->context.get())) {
-    case kWKCacheModelDocumentViewer:
+    switch (context->priv->context->cacheModel()) {
+    case CacheModelDocumentViewer:
         return WEBKIT_CACHE_MODEL_DOCUMENT_VIEWER;
-    case kWKCacheModelPrimaryWebBrowser:
+    case CacheModelPrimaryWebBrowser:
         return WEBKIT_CACHE_MODEL_WEB_BROWSER;
-    case kWKCacheModelDocumentBrowser:
+    case CacheModelDocumentBrowser:
         return WEBKIT_CACHE_MODEL_DOCUMENT_BROWSER;
     default:
         g_assert_not_reached();
@@ -268,11 +272,10 @@ void webkit_web_context_clear_cache(WebKitWebContext* context)
 {
     g_return_if_fail(WEBKIT_IS_WEB_CONTEXT(context));
 
-    WebKitWebContextPrivate* priv = context->priv;
-    WKResourceCacheManagerClearCacheForAllOrigins(WKContextGetResourceCacheManager(priv->context.get()), WKResourceCachesToClearAll);
+    context->priv->context->resourceCacheManagerProxy()->clearCacheForAllOrigins(AllResourceCaches);
 }
 
-typedef HashMap<WKDownloadRef, GRefPtr<WebKitDownload> > DownloadsMap;
+typedef HashMap<DownloadProxy*, GRefPtr<WebKitDownload> > DownloadsMap;
 
 static DownloadsMap& downloadsMap()
 {
@@ -295,12 +298,9 @@ WebKitDownload* webkit_web_context_download_uri(WebKitWebContext* context, const
     g_return_val_if_fail(WEBKIT_IS_WEB_CONTEXT(context), 0);
     g_return_val_if_fail(uri, 0);
 
-    WebKitWebContextPrivate* priv = context->priv;
-    WKRetainPtr<WKURLRef> wkURL(AdoptWK, WKURLCreateWithUTF8CString(uri));
-    WKRetainPtr<WKURLRequestRef> wkRequest(AdoptWK, WKURLRequestCreateWithWKURL(wkURL.get()));
-    WKRetainPtr<WKDownloadRef> wkDownload = WKContextDownloadURLRequest(priv->context.get(), wkRequest.get());
-    WebKitDownload* download = webkitDownloadCreate(wkDownload.get());
-    downloadsMap().set(wkDownload.get(), download);
+    DownloadProxy* downloadProxy = context->priv->context->download(0, WebCore::ResourceRequest(String::fromUTF8(uri)));
+    WebKitDownload* download = webkitDownloadCreate(toAPI(downloadProxy));
+    downloadsMap().set(downloadProxy, download);
     return download;
 }
 
@@ -318,11 +318,107 @@ WebKitCookieManager* webkit_web_context_get_cookie_manager(WebKitWebContext* con
 
     WebKitWebContextPrivate* priv = context->priv;
     if (!priv->cookieManager)
-        priv->cookieManager = adoptGRef(webkitCookieManagerCreate(WKContextGetCookieManager(priv->context.get())));
+        priv->cookieManager = adoptGRef(webkitCookieManagerCreate(toAPI(priv->context->cookieManagerProxy())));
 
     return priv->cookieManager.get();
 }
 
+static void ensureFaviconDatabase(WebKitWebContext* context)
+{
+    WebKitWebContextPrivate* priv = context->priv;
+    if (priv->faviconDatabase)
+        return;
+
+    priv->faviconDatabase = adoptGRef(webkitFaviconDatabaseCreate(priv->context->iconDatabase()));
+}
+
+/**
+ * webkit_web_context_set_favicon_database_directory:
+ * @context: a #WebKitWebContext
+ * @path: (allow-none): an absolute path to the icon database
+ * directory or %NULL to use the defaults
+ *
+ * Set the directory path to be used to store the favicons database
+ * for @context on disk. Passing %NULL as @path means using the
+ * default directory for the platform (see g_get_user_data_dir()).
+ *
+ * Calling this method also means enabling the favicons database for
+ * its use from the applications, so that's why it's expected to be
+ * called only once. Further calls for the same instance of
+ * #WebKitWebContext won't cause any effect.
+ */
+void webkit_web_context_set_favicon_database_directory(WebKitWebContext* context, const gchar* path)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_CONTEXT(context));
+
+    WebKitWebContextPrivate* priv = context->priv;
+    WebIconDatabase* iconDatabase = priv->context->iconDatabase();
+    if (iconDatabase->isOpen())
+        return;
+
+    ensureFaviconDatabase(context);
+
+    // Use default if 0 is passed as parameter.
+    String directoryPath = WebCore::filenameToString(path);
+    priv->faviconDatabaseDirectory = directoryPath.isEmpty()
+        ? priv->context->iconDatabasePath().utf8()
+        : directoryPath.utf8();
+
+    // Build the full path to the icon database file on disk.
+    GOwnPtr<gchar> faviconDatabasePath(g_build_filename(priv->faviconDatabaseDirectory.data(),
+                                                        WebCore::IconDatabase::defaultDatabaseFilename().utf8().data(),
+                                                        NULL));
+
+    // Setting the path will cause the icon database to be opened.
+    priv->context->setIconDatabasePath(WebCore::filenameToString(faviconDatabasePath.get()));
+}
+
+/**
+ * webkit_web_context_get_favicon_database_directory:
+ * @context: a #WebKitWebContext
+ *
+ * Get the directory path being used to store the favicons database
+ * for @context, or %NULL if
+ * webkit_web_context_set_favicon_database_directory() hasn't been
+ * called yet.
+ *
+ * This function will always return the same path after having called
+ * webkit_web_context_set_favicon_database_directory() for the first
+ * time.
+ *
+ * Returns: (transfer none): the path of the directory of the favicons
+ * database associated with @context, or %NULL.
+ */
+const gchar* webkit_web_context_get_favicon_database_directory(WebKitWebContext *context)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_CONTEXT(context), 0);
+
+    WebKitWebContextPrivate* priv = context->priv;
+    if (priv->faviconDatabaseDirectory.isNull())
+        return 0;
+
+    return priv->faviconDatabaseDirectory.data();
+}
+
+/**
+ * webkit_web_context_get_favicon_database:
+ * @context: a #WebKitWebContext
+ *
+ * Get the #WebKitFaviconDatabase associated with @context.
+ *
+ * To initialize the database you need to call
+ * webkit_web_context_set_favicon_database_directory().
+ *
+ * Returns: (transfer none): the #WebKitFaviconDatabase of @context.
+ */
+WebKitFaviconDatabase* webkit_web_context_get_favicon_database(WebKitWebContext* context)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_CONTEXT(context), 0);
+
+    ensureFaviconDatabase(context);
+    return context->priv->faviconDatabase.get();
+}
+
 /**
  * webkit_web_context_get_security_manager:
  * @context: a #WebKitWebContext
@@ -354,7 +450,7 @@ void webkit_web_context_set_additional_plugins_directory(WebKitWebContext* conte
     g_return_if_fail(WEBKIT_IS_WEB_CONTEXT(context));
     g_return_if_fail(directory);
 
-    toImpl(context->priv->context.get())->setAdditionalPluginsDirectory(WebCore::filenameToString(directory));
+    context->priv->context->setAdditionalPluginsDirectory(WebCore::filenameToString(directory));
 }
 
 struct GetPluginsAsyncData {
@@ -365,7 +461,7 @@ WEBKIT_DEFINE_ASYNC_DATA_STRUCT(GetPluginsAsyncData)
 static void webkitWebContextGetPluginThread(GSimpleAsyncResult* result, GObject* object, GCancellable*)
 {
     GetPluginsAsyncData* data = static_cast<GetPluginsAsyncData*>(g_simple_async_result_get_op_res_gpointer(result));
-    data->plugins = toImpl(WEBKIT_WEB_CONTEXT(object)->priv->context.get())->pluginInfoStore().plugins();
+    data->plugins = WEBKIT_WEB_CONTEXT(object)->priv->context->pluginInfoStore().plugins();
 }
 
 /**
@@ -472,8 +568,7 @@ void webkit_web_context_register_uri_scheme(WebKitWebContext* context, const cha
 
     RefPtr<WebKitURISchemeHandler> handler = adoptRef(new WebKitURISchemeHandler(callback, userData, destroyNotify));
     context->priv->uriSchemeHandlers.set(String::fromUTF8(scheme), handler.get());
-    WKRetainPtr<WKStringRef> wkScheme(AdoptWK, WKStringCreateWithUTF8CString(scheme));
-    WKSoupRequestManagerRegisterURIScheme(context->priv->requestManager.get(), wkScheme.get());
+    context->priv->requestManager->registerURIScheme(String::fromUTF8(scheme));
 }
 
 /**
@@ -587,20 +682,20 @@ void webkit_web_context_set_preferred_languages(WebKitWebContext* context, const
     WebCore::languageDidChange();
 }
 
-WebKitDownload* webkitWebContextGetOrCreateDownload(WKDownloadRef wkDownload)
+WebKitDownload* webkitWebContextGetOrCreateDownload(DownloadProxy* downloadProxy)
 {
-    GRefPtr<WebKitDownload> download = downloadsMap().get(wkDownload);
+    GRefPtr<WebKitDownload> download = downloadsMap().get(downloadProxy);
     if (download)
         return download.get();
 
-    download = adoptGRef(webkitDownloadCreate(wkDownload));
-    downloadsMap().set(wkDownload, download.get());
+    download = adoptGRef(webkitDownloadCreate(toAPI(downloadProxy)));
+    downloadsMap().set(downloadProxy, download.get());
     return download.get();
 }
 
-void webkitWebContextRemoveDownload(WKDownloadRef wkDownload)
+void webkitWebContextRemoveDownload(DownloadProxy* downloadProxy)
 {
-    downloadsMap().remove(wkDownload);
+    downloadsMap().remove(downloadProxy);
 }
 
 void webkitWebContextDownloadStarted(WebKitWebContext* context, WebKitDownload* download)
@@ -608,14 +703,14 @@ void webkitWebContextDownloadStarted(WebKitWebContext* context, WebKitDownload*
     g_signal_emit(context, signals[DOWNLOAD_STARTED], 0, download);
 }
 
-WKContextRef webkitWebContextGetWKContext(WebKitWebContext* context)
+WebContext* webkitWebContextGetContext(WebKitWebContext* context)
 {
     g_assert(WEBKIT_IS_WEB_CONTEXT(context));
 
     return context->priv->context.get();
 }
 
-WKSoupRequestManagerRef webkitWebContextGetRequestManager(WebKitWebContext* context)
+WebSoupRequestManagerProxy* webkitWebContextGetRequestManager(WebKitWebContext* context)
 {
     return context->priv->requestManager.get();
 }
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.h b/Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.h
index f77086f4d..ae79bec87 100644
--- a/Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.h
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitWebContext.h
@@ -28,6 +28,7 @@
 #include <webkit2/WebKitCookieManager.h>
 #include <webkit2/WebKitDefines.h>
 #include <webkit2/WebKitDownload.h>
+#include <webkit2/WebKitFaviconDatabase.h>
 #include <webkit2/WebKitSecurityManager.h>
 #include <webkit2/WebKitURISchemeRequest.h>
 
@@ -114,6 +115,15 @@ webkit_web_context_download_uri                     (WebKitWebContext
 WEBKIT_API WebKitCookieManager *
 webkit_web_context_get_cookie_manager               (WebKitWebContext              *context);
 
+WEBKIT_API WebKitFaviconDatabase *
+webkit_web_context_get_favicon_database             (WebKitWebContext              *context);
+
+WEBKIT_API void
+webkit_web_context_set_favicon_database_directory   (WebKitWebContext              *context,
+                                                     const gchar                   *path);
+WEBKIT_API const gchar *
+webkit_web_context_get_favicon_database_directory   (WebKitWebContext              *context);
+
 WEBKIT_API WebKitSecurityManager *
 webkit_web_context_get_security_manager             (WebKitWebContext              *context);
 
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitWebContextPrivate.h b/Source/WebKit2/UIProcess/API/gtk/WebKitWebContextPrivate.h
index 9e5536b3a..67be48d5c 100644
--- a/Source/WebKit2/UIProcess/API/gtk/WebKitWebContextPrivate.h
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitWebContextPrivate.h
@@ -26,15 +26,20 @@
 #ifndef WebKitWebContextPrivate_h
 #define WebKitWebContextPrivate_h
 
+#include "DownloadProxy.h"
+#include "WebContext.h"
 #include "WebKitPrivate.h"
 #include "WebKitURISchemeRequest.h"
 #include "WebKitWebContext.h"
+#include "WebSoupRequestManagerProxy.h"
 
-WKContextRef webkitWebContextGetWKContext(WebKitWebContext*);
-WebKitDownload* webkitWebContextGetOrCreateDownload(WKDownloadRef);
-void webkitWebContextRemoveDownload(WKDownloadRef);
+using namespace WebKit;
+
+WebContext* webkitWebContextGetContext(WebKitWebContext*);
+WebKitDownload* webkitWebContextGetOrCreateDownload(DownloadProxy*);
+void webkitWebContextRemoveDownload(DownloadProxy*);
 void webkitWebContextDownloadStarted(WebKitWebContext*, WebKitDownload*);
-WKSoupRequestManagerRef webkitWebContextGetRequestManager(WebKitWebContext*);
+WebSoupRequestManagerProxy* webkitWebContextGetRequestManager(WebKitWebContext*);
 void webkitWebContextReceivedURIRequest(WebKitWebContext*, WebKitURISchemeRequest*);
 void webkitWebContextDidFailToLoadURIRequest(WebKitWebContext*, uint64_t requestID);
 void webkitWebContextDidFinishURIRequest(WebKitWebContext*, uint64_t requestID);
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp b/Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp
index 301be899c..236a4f304 100644
--- a/Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp
@@ -30,6 +30,7 @@
 #include "WebKitContextMenuPrivate.h"
 #include "WebKitEnumTypes.h"
 #include "WebKitError.h"
+#include "WebKitFaviconDatabasePrivate.h"
 #include "WebKitFormClient.h"
 #include "WebKitFullscreenClient.h"
 #include "WebKitHitTestResultPrivate.h"
@@ -56,6 +57,7 @@
 #include <WebCore/DragIcon.h>
 #include <WebCore/GOwnPtrGtk.h>
 #include <WebCore/GtkUtilities.h>
+#include <WebCore/RefPtrCairo.h>
 #include <glib/gi18n-lib.h>
 #include <wtf/gobject/GOwnPtr.h>
 #include <wtf/gobject/GRefPtr.h>
@@ -102,6 +104,7 @@ enum {
     PROP_WEB_CONTEXT,
     PROP_TITLE,
     PROP_ESTIMATED_LOAD_PROGRESS,
+    PROP_FAVICON,
     PROP_URI,
     PROP_ZOOM_LEVEL,
     PROP_IS_LOADING
@@ -120,6 +123,7 @@ struct _WebKitWebViewPrivate {
 
     bool waitingForMainResource;
     gulong mainResourceResponseHandlerID;
+    gulong watchForChangesInFaviconHandlerID;
     WebKitLoadEvent lastDelayedEvent;
 
     GRefPtr<WebKitBackForwardList> backForwardList;
@@ -139,6 +143,9 @@ struct _WebKitWebViewPrivate {
     ResourcesMap subresourcesMap;
 
     GRefPtr<WebKitWebInspector> inspector;
+
+    RefPtr<cairo_surface_t> favicon;
+    GRefPtr<GCancellable> faviconCancellable;
 };
 
 static guint signals[LAST_SIGNAL] = { 0, };
@@ -260,6 +267,37 @@ static void userAgentChanged(WebKitSettings* settings, GParamSpec*, WebKitWebVie
     getPage(webView)->setCustomUserAgent(String::fromUTF8(webkit_settings_get_user_agent(settings)));
 }
 
+static void webkitWebViewCancelFaviconRequest(WebKitWebView* webView)
+{
+    if (!webView->priv->faviconCancellable)
+        return;
+
+    g_cancellable_cancel(webView->priv->faviconCancellable.get());
+    webView->priv->faviconCancellable = 0;
+}
+
+static void webkitWebViewUpdateFavicon(WebKitWebView* webView, cairo_surface_t* favicon)
+{
+    if (webView->priv->favicon.get() == favicon)
+        return;
+
+    webView->priv->favicon = favicon;
+    g_object_notify(G_OBJECT(webView), "favicon");
+}
+
+static void iconReadyCallback(WebKitFaviconDatabase* database, const char* uri, WebKitWebView* webView)
+{
+    // Consider only the icon matching the active URI for this webview.
+    if (webView->priv->activeURI != uri)
+        return;
+
+    // Update the favicon only if we don't have one already.
+    if (!webView->priv->favicon) {
+        RefPtr<cairo_surface_t> favicon = adoptRef(webkitFaviconDatabaseGetFavicon(database, webView->priv->activeURI));
+        webkitWebViewUpdateFavicon(webView, favicon.get());
+    }
+}
+
 static void webkitWebViewSetSettings(WebKitWebView* webView, WebKitSettings* settings)
 {
     webView->priv->settings = settings;
@@ -285,6 +323,29 @@ static void webkitWebViewDisconnectMainResourceResponseChangedSignalHandler(WebK
     priv->mainResourceResponseHandlerID = 0;
 }
 
+static void webkitWebViewWatchForChangesInFavicon(WebKitWebView* webView)
+{
+    WebKitWebViewPrivate* priv = webView->priv;
+    WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(priv->context);
+
+    // Make sure we only connect to this signal once per view.
+    if (priv->watchForChangesInFaviconHandlerID)
+        return;
+
+    priv->watchForChangesInFaviconHandlerID =
+        g_signal_connect(database, "favicon-ready", G_CALLBACK(iconReadyCallback), webView);
+}
+
+static void webkitWebViewDisconnectFaviconDatabaseSignalHandlers(WebKitWebView* webView)
+{
+    WebKitWebViewPrivate* priv = webView->priv;
+    WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(priv->context);
+
+    if (priv->watchForChangesInFaviconHandlerID)
+        g_signal_handler_disconnect(database, priv->watchForChangesInFaviconHandlerID);
+    priv->watchForChangesInFaviconHandlerID = 0;
+}
+
 static void fileChooserDialogResponseCallback(GtkDialog* dialog, gint responseID, WebKitFileChooserRequest* request)
 {
     GRefPtr<WebKitFileChooserRequest> adoptedRequest = adoptGRef(request);
@@ -337,7 +398,7 @@ static void webkitWebViewConstructed(GObject* object)
     WebKitWebViewPrivate* priv = webView->priv;
     WebKitWebViewBase* webViewBase = WEBKIT_WEB_VIEW_BASE(webView);
 
-    webkitWebViewBaseCreateWebPage(webViewBase, toImpl(webkitWebContextGetWKContext(priv->context)), 0);
+    webkitWebViewBaseCreateWebPage(webViewBase, webkitWebContextGetContext(priv->context), 0);
 
     attachLoaderClientToView(webView);
     attachUIClientToView(webView);
@@ -385,6 +446,9 @@ static void webkitWebViewGetProperty(GObject* object, guint propId, GValue* valu
     case PROP_ESTIMATED_LOAD_PROGRESS:
         g_value_set_double(value, webkit_web_view_get_estimated_load_progress(webView));
         break;
+    case PROP_FAVICON:
+        g_value_set_pointer(value, webkit_web_view_get_favicon(webView));
+        break;
     case PROP_URI:
         g_value_set_string(value, webkit_web_view_get_uri(webView));
         break;
@@ -411,8 +475,10 @@ static void webkitWebViewFinalize(GObject* object)
     if (priv->modalLoop && g_main_loop_is_running(priv->modalLoop.get()))
         g_main_loop_quit(priv->modalLoop.get());
 
+    webkitWebViewCancelFaviconRequest(webView);
     webkitWebViewDisconnectMainResourceResponseChangedSignalHandler(webView);
     webkitWebViewDisconnectSettingsSignalHandlers(webView);
+    webkitWebViewDisconnectFaviconDatabaseSignalHandlers(webView);
 
     priv->~WebKitWebViewPrivate();
     G_OBJECT_CLASS(webkit_web_view_parent_class)->finalize(object);
@@ -500,6 +566,18 @@ static void webkit_web_view_class_init(WebKitWebViewClass* webViewClass)
                                                         0.0, 1.0, 0.0,
                                                         WEBKIT_PARAM_READABLE));
     /**
+     * WebKitWebView:favicon:
+     *
+     * The favicon currently associated to the #WebKitWebView.
+     * See webkit_web_view_get_favicon() for more details.
+     */
+    g_object_class_install_property(gObjectClass,
+                                    PROP_FAVICON,
+                                    g_param_spec_pointer("favicon",
+                                                         _("Favicon"),
+                                                         _("The favicon associated to the view, if any"),
+                                                         WEBKIT_PARAM_READABLE));
+    /**
      * WebKitWebView:uri:
      *
      * The current active URI of the #WebKitWebView.
@@ -1158,9 +1236,10 @@ static void setCertificateToMainResource(WebKitWebView* webView)
 
 static void webkitWebViewEmitLoadChanged(WebKitWebView* webView, WebKitLoadEvent loadEvent)
 {
-    if (loadEvent == WEBKIT_LOAD_STARTED)
+    if (loadEvent == WEBKIT_LOAD_STARTED) {
         webkitWebViewSetIsLoading(webView, true);
-    else if (loadEvent == WEBKIT_LOAD_FINISHED) {
+        webkitWebViewWatchForChangesInFavicon(webView);
+    } else if (loadEvent == WEBKIT_LOAD_FINISHED) {
         webkitWebViewSetIsLoading(webView, false);
         webView->priv->waitingForMainResource = false;
         webkitWebViewDisconnectMainResourceResponseChangedSignalHandler(webView);
@@ -1182,29 +1261,52 @@ static void webkitWebViewEmitDelayedLoadEvents(WebKitWebView* webView)
     priv->waitingForMainResource = false;
 }
 
+static void getFaviconReadyCallback(GObject* object, GAsyncResult* result, gpointer userData)
+{
+    GOwnPtr<GError> error;
+    RefPtr<cairo_surface_t> favicon = adoptRef(webkit_favicon_database_get_favicon_finish(WEBKIT_FAVICON_DATABASE(object), result, &error.outPtr()));
+    if (!g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
+        WebKitWebView* webView = WEBKIT_WEB_VIEW(userData);
+        webkitWebViewUpdateFavicon(webView, favicon.get());
+        webView->priv->faviconCancellable = 0;
+    }
+}
+
+static void webkitWebViewRequestFavicon(WebKitWebView* webView)
+{
+    WebKitWebViewPrivate* priv = webView->priv;
+    WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(priv->context);
+    priv->faviconCancellable = adoptGRef(g_cancellable_new());
+    webkit_favicon_database_get_favicon(database, priv->activeURI.data(), priv->faviconCancellable.get(), getFaviconReadyCallback, webView);
+}
+
 void webkitWebViewLoadChanged(WebKitWebView* webView, WebKitLoadEvent loadEvent)
 {
+    WebKitWebViewPrivate* priv = webView->priv;
     if (loadEvent == WEBKIT_LOAD_STARTED) {
         // Finish a possible previous load waiting for main resource.
         webkitWebViewEmitDelayedLoadEvents(webView);
 
-        webView->priv->loadingResourcesMap.clear();
-        webView->priv->mainResource = 0;
-        webView->priv->waitingForMainResource = false;
+        webkitWebViewCancelFaviconRequest(webView);
+        priv->loadingResourcesMap.clear();
+        priv->mainResource = 0;
+        priv->waitingForMainResource = false;
     } else if (loadEvent == WEBKIT_LOAD_COMMITTED) {
-        webView->priv->subresourcesMap.clear();
-        if (!webView->priv->mainResource) {
+        webkitWebViewRequestFavicon(webView);
+
+        priv->subresourcesMap.clear();
+        if (!priv->mainResource) {
             // When a page is loaded from the history cache, the main resource load callbacks
             // are called when the main frame load is finished. We want to make sure there's a
             // main resource available when load has been committed, so we delay the emission of
             // load-changed signal until main resource object has been created.
-            webView->priv->waitingForMainResource = true;
+            priv->waitingForMainResource = true;
         } else
             setCertificateToMainResource(webView);
     }
 
-    if (webView->priv->waitingForMainResource)
-        webView->priv->lastDelayedEvent = loadEvent;
+    if (priv->waitingForMainResource)
+        priv->lastDelayedEvent = loadEvent;
     else
         webkitWebViewEmitLoadChanged(webView, loadEvent);
 }
@@ -1850,6 +1952,26 @@ const gchar* webkit_web_view_get_uri(WebKitWebView* webView)
 }
 
 /**
+ * webkit_web_view_get_favicon:
+ * @web_view: a #WebKitWebView
+ *
+ * Returns favicon currently associated to @web_view, if any. You can
+ * connect to notify::favicon signal of @web_view to be notified when
+ * the favicon is available.
+ *
+ * Returns: (transfer none): a pointer to a #cairo_surface_t with the
+ *    favicon or %NULL if there's no icon associated with @web_view.
+ */
+cairo_surface_t* webkit_web_view_get_favicon(WebKitWebView* webView)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
+    if (webView->priv->activeURI.isNull())
+        return 0;
+
+    return webView->priv->favicon.get();
+}
+
+/**
  * webkit_web_view_get_custom_charset:
  * @web_view: a #WebKitWebView
  *
@@ -2192,7 +2314,7 @@ static void webkitWebViewRunJavaScriptCallback(WKSerializedScriptValueRef wkSeri
         g_simple_async_result_take_error(result.get(), error);
     else if (wkSerializedScriptValue) {
         GRefPtr<WebKitWebView> webView = adoptGRef(WEBKIT_WEB_VIEW(g_async_result_get_source_object(G_ASYNC_RESULT(result.get()))));
-        data->scriptResult = webkitJavascriptResultCreate(webView.get(), wkSerializedScriptValue);
+        data->scriptResult = webkitJavascriptResultCreate(webView.get(), toImpl(wkSerializedScriptValue));
     } else {
         g_set_error_literal(&error, WEBKIT_JAVASCRIPT_ERROR, WEBKIT_JAVASCRIPT_ERROR_SCRIPT_FAILED, _("An exception was raised in JavaScript"));
         g_simple_async_result_take_error(result.get(), error);
@@ -2307,6 +2429,94 @@ WebKitJavascriptResult* webkit_web_view_run_javascript_finish(WebKitWebView* web
     return data->scriptResult ? webkit_javascript_result_ref(data->scriptResult) : 0;
 }
 
+static void resourcesStreamReadCallback(GObject* object, GAsyncResult* result, gpointer userData)
+{
+    GOutputStream* outputStream = G_OUTPUT_STREAM(object);
+    GRefPtr<GSimpleAsyncResult> runJavascriptResult = adoptGRef(G_SIMPLE_ASYNC_RESULT(userData));
+
+    GError* error = 0;
+    g_output_stream_splice_finish(outputStream, result, &error);
+    if (error) {
+        g_simple_async_result_take_error(runJavascriptResult.get(), error);
+        g_simple_async_result_complete(runJavascriptResult.get());
+        return;
+    }
+
+    GRefPtr<WebKitWebView> webView = adoptGRef(WEBKIT_WEB_VIEW(g_async_result_get_source_object(G_ASYNC_RESULT(runJavascriptResult.get()))));
+    gpointer outputStreamData = g_memory_output_stream_get_data(G_MEMORY_OUTPUT_STREAM(outputStream));
+    getPage(webView.get())->runJavaScriptInMainFrame(String::fromUTF8(reinterpret_cast<const gchar*>(outputStreamData)),
+                                                     ScriptValueCallback::create(runJavascriptResult.leakRef(), webkitWebViewRunJavaScriptCallback));
+}
+
+/**
+ * webkit_web_view_run_javascript_from_gresource:
+ * @web_view: a #WebKitWebView
+ * @resource: the location of the resource to load
+ * @cancellable: (allow-none): a #GCancellable or %NULL to ignore
+ * @callback: (scope async): a #GAsyncReadyCallback to call when the script finished
+ * @user_data: (closure): the data to pass to callback function
+ *
+ * Asynchronously run the script from @resource in the context of the
+ * current page in @web_view.
+ *
+ * When the operation is finished, @callback will be called. You can
+ * then call webkit_web_view_run_javascript_from_gresource_finish() to get the result
+ * of the operation.
+ */
+void webkit_web_view_run_javascript_from_gresource(WebKitWebView* webView, const gchar* resource, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+    g_return_if_fail(resource);
+
+    GRefPtr<GSimpleAsyncResult> result = adoptGRef(g_simple_async_result_new(G_OBJECT(webView), callback, userData,
+                                                                             reinterpret_cast<gpointer>(webkit_web_view_run_javascript_from_gresource)));
+    RunJavaScriptAsyncData* data = createRunJavaScriptAsyncData();
+    data->cancellable = cancellable;
+    g_simple_async_result_set_op_res_gpointer(result.get(), data, reinterpret_cast<GDestroyNotify>(destroyRunJavaScriptAsyncData));
+
+    GError* error = 0;
+    GRefPtr<GInputStream> inputStream = adoptGRef(g_resources_open_stream(resource, G_RESOURCE_LOOKUP_FLAGS_NONE, &error));
+    if (error) {
+        g_simple_async_result_take_error(result.get(), error);
+        g_simple_async_result_complete_in_idle(result.get());
+        return;
+    }
+
+    GRefPtr<GOutputStream> outputStream = adoptGRef(g_memory_output_stream_new(0, 0, fastRealloc, fastFree));
+    g_output_stream_splice_async(outputStream.get(), inputStream.get(),
+                                 static_cast<GOutputStreamSpliceFlags>(G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET),
+                                 G_PRIORITY_DEFAULT,
+                                 cancellable, resourcesStreamReadCallback, result.leakRef());
+}
+
+/**
+ * webkit_web_view_run_javascript_from_gresource_finish:
+ * @web_view: a #WebKitWebView
+ * @result: a #GAsyncResult
+ * @error: return location for error or %NULL to ignore
+ *
+ * Finish an asynchronous operation started with webkit_web_view_run_javascript_from_gresource().
+ *
+ * Check webkit_web_view_run_javascript_finish() for a usage example.
+ *
+ * Returns: (transfer full): a #WebKitJavascriptResult with the result of the last executed statement in @script
+ *    or %NULL in case of error
+ */
+WebKitJavascriptResult* webkit_web_view_run_javascript_from_gresource_finish(WebKitWebView* webView, GAsyncResult* result, GError** error)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
+    g_return_val_if_fail(G_IS_ASYNC_RESULT(result), 0);
+
+    GSimpleAsyncResult* simpleResult = G_SIMPLE_ASYNC_RESULT(result);
+    g_warn_if_fail(g_simple_async_result_get_source_tag(simpleResult) == webkit_web_view_run_javascript_from_gresource);
+
+    if (g_simple_async_result_propagate_error(simpleResult, error))
+        return 0;
+
+    RunJavaScriptAsyncData* data = static_cast<RunJavaScriptAsyncData*>(g_simple_async_result_get_op_res_gpointer(simpleResult));
+    return data->scriptResult ? webkit_javascript_result_ref(data->scriptResult) : 0;
+}
+
 /**
  * webkit_web_view_get_main_resource:
  * @web_view: a #WebKitWebView
@@ -2341,7 +2551,7 @@ GList* webkit_web_view_get_subresources(WebKitWebView* webView)
     WebKitWebViewPrivate* priv = webView->priv;
     ResourcesMap::const_iterator end = priv->subresourcesMap.end();
     for (ResourcesMap::const_iterator it = priv->subresourcesMap.begin(); it != end; ++it)
-        subresources = g_list_prepend(subresources, it->second.get());
+        subresources = g_list_prepend(subresources, it->value.get());
 
     return g_list_reverse(subresources);
 }
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitWebView.h b/Source/WebKit2/UIProcess/API/gtk/WebKitWebView.h
index 8a397b752..ac2e2813f 100644
--- a/Source/WebKit2/UIProcess/API/gtk/WebKitWebView.h
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitWebView.h
@@ -191,170 +191,185 @@ struct _WebKitWebViewClass {
 };
 
 WEBKIT_API GType
-webkit_web_view_get_type                           (void);
+webkit_web_view_get_type                             (void);
 
 WEBKIT_API GtkWidget *
-webkit_web_view_new                                (void);
+webkit_web_view_new                                  (void);
 
 WEBKIT_API GtkWidget *
-webkit_web_view_new_with_context                   (WebKitWebContext          *context);
+webkit_web_view_new_with_context                     (WebKitWebContext          *context);
 
 WEBKIT_API WebKitWebContext *
-webkit_web_view_get_context                        (WebKitWebView             *web_view);
+webkit_web_view_get_context                          (WebKitWebView             *web_view);
 
 WEBKIT_API void
-webkit_web_view_load_uri                           (WebKitWebView             *web_view,
-                                                    const gchar               *uri);
+webkit_web_view_load_uri                             (WebKitWebView             *web_view,
+                                                      const gchar               *uri);
 
 WEBKIT_API void
-webkit_web_view_load_html                          (WebKitWebView             *web_view,
-                                                    const gchar               *content,
-                                                    const gchar               *base_uri);
+webkit_web_view_load_html                            (WebKitWebView             *web_view,
+                                                      const gchar               *content,
+                                                      const gchar               *base_uri);
 WEBKIT_API void
-webkit_web_view_load_alternate_html                (WebKitWebView             *web_view,
-                                                    const gchar               *content,
-                                                    const gchar               *content_uri,
-                                                    const gchar               *base_uri);
+webkit_web_view_load_alternate_html                  (WebKitWebView             *web_view,
+                                                      const gchar               *content,
+                                                      const gchar               *content_uri,
+                                                      const gchar               *base_uri);
 WEBKIT_API void
-webkit_web_view_load_plain_text                    (WebKitWebView             *web_view,
-                                                    const gchar               *plain_text);
+webkit_web_view_load_plain_text                      (WebKitWebView             *web_view,
+                                                      const gchar               *plain_text);
 
 WEBKIT_API void
-webkit_web_view_load_request                       (WebKitWebView             *web_view,
-                                                    WebKitURIRequest          *request);
+webkit_web_view_load_request                         (WebKitWebView             *web_view,
+                                                      WebKitURIRequest          *request);
 
 WEBKIT_API void
-webkit_web_view_stop_loading                       (WebKitWebView             *web_view);
+webkit_web_view_stop_loading                         (WebKitWebView             *web_view);
 
 WEBKIT_API gboolean
-webkit_web_view_is_loading                         (WebKitWebView             *web_view);
+webkit_web_view_is_loading                           (WebKitWebView             *web_view);
 
 WEBKIT_API const gchar *
-webkit_web_view_get_title                          (WebKitWebView             *web_view);
+webkit_web_view_get_title                            (WebKitWebView             *web_view);
 
 WEBKIT_API void
-webkit_web_view_reload                             (WebKitWebView             *web_view);
+webkit_web_view_reload                               (WebKitWebView             *web_view);
 
 WEBKIT_API void
-webkit_web_view_reload_bypass_cache                (WebKitWebView             *web_view);
+webkit_web_view_reload_bypass_cache                  (WebKitWebView             *web_view);
 
 WEBKIT_API gdouble
-webkit_web_view_get_estimated_load_progress        (WebKitWebView             *web_view);
+webkit_web_view_get_estimated_load_progress          (WebKitWebView             *web_view);
 
 WEBKIT_API void
-webkit_web_view_go_back                            (WebKitWebView             *web_view);
+webkit_web_view_go_back                              (WebKitWebView             *web_view);
 
 WEBKIT_API gboolean
-webkit_web_view_can_go_back                        (WebKitWebView             *web_view);
+webkit_web_view_can_go_back                          (WebKitWebView             *web_view);
 
 WEBKIT_API void
-webkit_web_view_go_forward                         (WebKitWebView             *web_view);
+webkit_web_view_go_forward                           (WebKitWebView             *web_view);
 
 WEBKIT_API gboolean
-webkit_web_view_can_go_forward                     (WebKitWebView             *web_view);
+webkit_web_view_can_go_forward                       (WebKitWebView             *web_view);
 
 WEBKIT_API WebKitBackForwardList *
-webkit_web_view_get_back_forward_list              (WebKitWebView             *web_view);
+webkit_web_view_get_back_forward_list                (WebKitWebView             *web_view);
 
 WEBKIT_API void
-webkit_web_view_go_to_back_forward_list_item       (WebKitWebView             *web_view,
-                                                    WebKitBackForwardListItem *list_item);
+webkit_web_view_go_to_back_forward_list_item         (WebKitWebView             *web_view,
+                                                      WebKitBackForwardListItem *list_item);
 WEBKIT_API const gchar *
-webkit_web_view_get_uri                            (WebKitWebView             *web_view);
+webkit_web_view_get_uri                              (WebKitWebView             *web_view);
+
+WEBKIT_API cairo_surface_t *
+webkit_web_view_get_favicon                          (WebKitWebView             *web_view);
 
 WEBKIT_API const gchar *
-webkit_web_view_get_custom_charset                 (WebKitWebView             *web_view);
+webkit_web_view_get_custom_charset                   (WebKitWebView             *web_view);
 
 WEBKIT_API void
-webkit_web_view_set_custom_charset                 (WebKitWebView             *web_view,
-                                                    const gchar               *charset);
+webkit_web_view_set_custom_charset                   (WebKitWebView             *web_view,
+                                                      const gchar               *charset);
 
 WEBKIT_API void
-webkit_web_view_set_settings                       (WebKitWebView             *web_view,
-                                                    WebKitSettings            *settings);
+webkit_web_view_set_settings                         (WebKitWebView             *web_view,
+                                                      WebKitSettings            *settings);
 
 WEBKIT_API WebKitSettings *
-webkit_web_view_get_settings                       (WebKitWebView             *web_view);
+webkit_web_view_get_settings                         (WebKitWebView             *web_view);
 
 WEBKIT_API WebKitWindowProperties *
-webkit_web_view_get_window_properties              (WebKitWebView             *web_view);
+webkit_web_view_get_window_properties                (WebKitWebView             *web_view);
 
 WEBKIT_API void
-webkit_web_view_set_zoom_level                     (WebKitWebView             *web_view,
-                                                    gdouble                    zoom_level);
+webkit_web_view_set_zoom_level                       (WebKitWebView             *web_view,
+                                                      gdouble                    zoom_level);
 WEBKIT_API gdouble
-webkit_web_view_get_zoom_level                     (WebKitWebView             *web_view);
+webkit_web_view_get_zoom_level                       (WebKitWebView             *web_view);
 
 WEBKIT_API void
-webkit_web_view_can_execute_editing_command        (WebKitWebView             *web_view,
-                                                    const gchar               *command,
-                                                    GCancellable              *cancellable,
-                                                    GAsyncReadyCallback        callback,
-                                                    gpointer                   user_data);
+webkit_web_view_can_execute_editing_command          (WebKitWebView             *web_view,
+                                                      const gchar               *command,
+                                                      GCancellable              *cancellable,
+                                                      GAsyncReadyCallback        callback,
+                                                      gpointer                   user_data);
 
 WEBKIT_API gboolean
-webkit_web_view_can_execute_editing_command_finish (WebKitWebView             *web_view,
-                                                    GAsyncResult              *result,
-                                                    GError                   **error);
+webkit_web_view_can_execute_editing_command_finish   (WebKitWebView             *web_view,
+                                                      GAsyncResult              *result,
+                                                      GError                   **error);
 
 WEBKIT_API void
-webkit_web_view_execute_editing_command            (WebKitWebView             *web_view,
-                                                    const gchar               *command);
+webkit_web_view_execute_editing_command              (WebKitWebView             *web_view,
+                                                      const gchar               *command);
 
 WEBKIT_API WebKitFindController *
-webkit_web_view_get_find_controller                (WebKitWebView             *web_view);
+webkit_web_view_get_find_controller                  (WebKitWebView             *web_view);
 
 WEBKIT_API JSGlobalContextRef
-webkit_web_view_get_javascript_global_context      (WebKitWebView             *web_view);
+webkit_web_view_get_javascript_global_context        (WebKitWebView             *web_view);
 
 WEBKIT_API void
-webkit_web_view_run_javascript                     (WebKitWebView             *web_view,
-                                                    const gchar               *script,
-                                                    GCancellable              *cancellable,
-                                                    GAsyncReadyCallback        callback,
-                                                    gpointer                   user_data);
+webkit_web_view_run_javascript                       (WebKitWebView             *web_view,
+                                                      const gchar               *script,
+                                                      GCancellable              *cancellable,
+                                                      GAsyncReadyCallback        callback,
+                                                      gpointer                   user_data);
+WEBKIT_API WebKitJavascriptResult *
+webkit_web_view_run_javascript_finish                (WebKitWebView             *web_view,
+                                                      GAsyncResult              *result,
+                                                      GError                   **error);
+
+WEBKIT_API void
+webkit_web_view_run_javascript_from_gresource        (WebKitWebView             *web_view,
+                                                      const gchar               *resource,
+                                                      GCancellable              *cancellable,
+                                                      GAsyncReadyCallback        callback,
+                                                      gpointer                   user_data);
+
 WEBKIT_API WebKitJavascriptResult *
-webkit_web_view_run_javascript_finish              (WebKitWebView             *web_view,
-                                                    GAsyncResult              *result,
-                                                    GError                   **error);
+webkit_web_view_run_javascript_from_gresource_finish (WebKitWebView             *web_view,
+                                                      GAsyncResult              *result,
+                                                      GError                   **error);
 
 WEBKIT_API WebKitWebResource *
-webkit_web_view_get_main_resource                  (WebKitWebView             *web_view);
+webkit_web_view_get_main_resource                    (WebKitWebView             *web_view);
 
 WEBKIT_API GList *
-webkit_web_view_get_subresources                   (WebKitWebView             *web_view);
+webkit_web_view_get_subresources                     (WebKitWebView             *web_view);
 
 WEBKIT_API WebKitWebInspector *
-webkit_web_view_get_inspector                      (WebKitWebView             *web_view);
+webkit_web_view_get_inspector                        (WebKitWebView             *web_view);
 
 WEBKIT_API gboolean
-webkit_web_view_can_show_mime_type                 (WebKitWebView             *web_view,
-                                                    const gchar               *mime_type);
+webkit_web_view_can_show_mime_type                   (WebKitWebView             *web_view,
+                                                      const gchar               *mime_type);
 
 WEBKIT_API void
-webkit_web_view_save                               (WebKitWebView             *web_view,
-                                                    WebKitSaveMode             save_mode,
-                                                    GCancellable              *cancellable,
-                                                    GAsyncReadyCallback        callback,
-                                                    gpointer                   user_data);
+webkit_web_view_save                                 (WebKitWebView             *web_view,
+                                                      WebKitSaveMode             save_mode,
+                                                      GCancellable              *cancellable,
+                                                      GAsyncReadyCallback        callback,
+                                                      gpointer                   user_data);
 
 WEBKIT_API GInputStream *
-webkit_web_view_save_finish                        (WebKitWebView             *web_view,
-                                                    GAsyncResult              *result,
-                                                    GError                   **error);
+webkit_web_view_save_finish                          (WebKitWebView             *web_view,
+                                                      GAsyncResult              *result,
+                                                      GError                   **error);
 
 WEBKIT_API void
-webkit_web_view_save_to_file                       (WebKitWebView             *web_view,
-                                                    GFile                     *file,
-                                                    WebKitSaveMode             save_mode,
-                                                    GCancellable              *cancellable,
-                                                    GAsyncReadyCallback        callback,
-                                                    gpointer                   user_data);
+webkit_web_view_save_to_file                         (WebKitWebView             *web_view,
+                                                      GFile                     *file,
+                                                      WebKitSaveMode             save_mode,
+                                                      GCancellable              *cancellable,
+                                                      GAsyncReadyCallback        callback,
+                                                      gpointer                   user_data);
 
 WEBKIT_API gboolean
-webkit_web_view_save_to_file_finish                (WebKitWebView             *web_view,
-                                                    GAsyncResult              *result,
-                                                    GError                   **error);
+webkit_web_view_save_to_file_finish                  (WebKitWebView             *web_view,
+                                                      GAsyncResult              *result,
+                                                      GError                   **error);
 
 G_END_DECLS
 
diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp b/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp
index b42b2ee8f..e5bac671e 100644
--- a/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp
@@ -75,6 +75,10 @@ using namespace WebCore;
 
 typedef HashMap<GtkWidget*, IntRect> WebKitWebViewChildrenMap;
 
+#if USE(TEXTURE_MAPPER_GL)
+void redirectedWindowDamagedCallback(void* data);
+#endif
+
 struct _WebKitWebViewBasePrivate {
     WebKitWebViewChildrenMap children;
     OwnPtr<PageClientImpl> pageClient;
@@ -111,7 +115,6 @@ struct _WebKitWebViewBasePrivate {
 
 #if USE(TEXTURE_MAPPER_GL)
     OwnPtr<RedirectedXCompositeWindow> redirectedWindow;
-    bool readyToRenderAcceleratedCompositingResults;
 #endif
 };
 
@@ -300,7 +303,7 @@ static void webkitWebViewBaseContainerForall(GtkContainer* container, gboolean i
     WebKitWebViewChildrenMap children = priv->children;
     WebKitWebViewChildrenMap::const_iterator end = children.end();
     for (WebKitWebViewChildrenMap::const_iterator current = children.begin(); current != end; ++current)
-        (*callback)(current->first, callbackData);
+        (*callback)(current->key, callbackData);
 
     if (includeInternals && priv->inspectorView)
         (*callback)(priv->inspectorView, callbackData);
@@ -351,7 +354,8 @@ static void webkit_web_view_base_init(WebKitWebViewBase* webkitWebViewBase)
 
 #if USE(TEXTURE_MAPPER_GL)
     priv->redirectedWindow = RedirectedXCompositeWindow::create(IntSize(1, 1));
-    priv->readyToRenderAcceleratedCompositingResults = false;
+    if (priv->redirectedWindow)
+        priv->redirectedWindow->setDamageNotifyCallback(redirectedWindowDamagedCallback, webkitWebViewBase);
 #endif
 }
 
@@ -364,10 +368,9 @@ static bool webkitWebViewRenderAcceleratedCompositingResults(WebKitWebViewBase*
     // To avoid flashes when initializing accelerated compositing for the first
     // time, we wait until we know there's a frame ready before rendering.
     WebKitWebViewBasePrivate* priv = webViewBase->priv;
-    if (!priv->readyToRenderAcceleratedCompositingResults)
+    if (!priv->redirectedWindow)
         return false;
 
-    ASSERT(priv->redirectedWindow);
     cairo_rectangle(cr, clipRect->x, clipRect->y, clipRect->width, clipRect->height);
     cairo_surface_t* surface = priv->redirectedWindow->cairoSurfaceForWidget(GTK_WIDGET(webViewBase));
     cairo_set_source_surface(cr, surface, 0, 0);
@@ -430,7 +433,7 @@ static void resizeWebKitWebViewBaseFromAllocation(WebKitWebViewBase* webViewBase
     }
 
 #if USE(TEXTURE_MAPPER_GL)
-    if (sizeChanged)
+    if (sizeChanged && webViewBase->priv->redirectedWindow)
         webViewBase->priv->redirectedWindow->resize(viewRect.size());
 #endif
 
@@ -801,7 +804,8 @@ void webkitWebViewBaseCreateWebPage(WebKitWebViewBase* webkitWebViewBase, WebCon
 #endif
 
 #if USE(TEXTURE_MAPPER_GL)
-    priv->pageProxy->setAcceleratedCompositingWindowId(priv->redirectedWindow->windowId());
+    if (priv->redirectedWindow)
+        priv->pageProxy->setAcceleratedCompositingWindowId(priv->redirectedWindow->windowId());
 #endif
 }
 
@@ -928,37 +932,9 @@ GdkEvent* webkitWebViewBaseTakeContextMenuEvent(WebKitWebViewBase* webkitWebView
 }
 
 #if USE(TEXTURE_MAPPER_GL)
-static gboolean queueAnotherDrawOfAcceleratedCompositingResults(gpointer* webViewBasePointer)
+void redirectedWindowDamagedCallback(void* data)
 {
-    // The WebViewBase may have been destroyed in the time since we queued this
-    // draw and the time we are actually executing.
-    if (!*webViewBasePointer) {
-        fastFree(webViewBasePointer);
-        return FALSE;
-    }
-
-    WebKitWebViewBase* webViewBase = WEBKIT_WEB_VIEW_BASE(*webViewBasePointer);
-    gtk_widget_queue_draw(GTK_WIDGET(webViewBase));
-    webViewBase->priv->readyToRenderAcceleratedCompositingResults = true;
-
-    g_object_remove_weak_pointer(G_OBJECT(webViewBase), webViewBasePointer);
-    fastFree(webViewBasePointer);
-
-    return FALSE;
-}
-
-void webkitWebViewBaseQueueDrawOfAcceleratedCompositingResults(WebKitWebViewBase* webViewBase)
-{
-    gtk_widget_queue_draw(GTK_WIDGET(webViewBase));
-
-    // Redraw again, one frame later, as it might take some time for the new GL frame to be available.
-    // This prevents the display from always being one frame behind in the case GL hasn't yet finished
-    // rendering to the window.
-    // TODO: Add XDamage support to RedirectedXCompositeWindow to accomplish this.
-    gpointer* webViewBasePointer = static_cast<gpointer*>(fastMalloc(sizeof(gpointer)));
-    g_object_add_weak_pointer(G_OBJECT(webViewBase), webViewBasePointer);
-    *webViewBasePointer = webViewBase;
-    g_timeout_add(1000 / 60, reinterpret_cast<GSourceFunc>(queueAnotherDrawOfAcceleratedCompositingResults), webViewBasePointer);
+    gtk_widget_queue_draw(GTK_WIDGET(data));
 }
 #endif
 
diff --git a/Source/WebKit2/UIProcess/API/gtk/docs/webkit2gtk-docs.sgml b/Source/WebKit2/UIProcess/API/gtk/docs/webkit2gtk-docs.sgml
index a7f34e6d1..8623af33e 100644
--- a/Source/WebKit2/UIProcess/API/gtk/docs/webkit2gtk-docs.sgml
+++ b/Source/WebKit2/UIProcess/API/gtk/docs/webkit2gtk-docs.sgml
@@ -30,6 +30,7 @@
     <xi:include href="xml/WebKitPrintOperation.xml"/>
     <xi:include href="xml/WebKitWebResource.xml"/>
     <xi:include href="xml/WebKitError.xml"/>
+    <xi:include href="xml/WebKitFaviconDatabase.xml"/>
     <xi:include href="xml/WebKitFileChooserRequest.xml"/>
     <xi:include href="xml/WebKitFindController.xml"/>
     <xi:include href="xml/WebKitCookieManager.xml"/>
diff --git a/Source/WebKit2/UIProcess/API/gtk/docs/webkit2gtk-sections.txt b/Source/WebKit2/UIProcess/API/gtk/docs/webkit2gtk-sections.txt
index 1827b6b16..f56267b9a 100644
--- a/Source/WebKit2/UIProcess/API/gtk/docs/webkit2gtk-sections.txt
+++ b/Source/WebKit2/UIProcess/API/gtk/docs/webkit2gtk-sections.txt
@@ -30,6 +30,9 @@ webkit_web_context_set_cache_model
 webkit_web_context_clear_cache
 webkit_web_context_download_uri
 webkit_web_context_get_cookie_manager
+webkit_web_context_get_favicon_database
+webkit_web_context_set_favicon_database_directory
+webkit_web_context_get_favicon_database_directory
 webkit_web_context_get_security_manager
 webkit_web_context_set_additional_plugins_directory
 webkit_web_context_get_plugins
@@ -98,6 +101,7 @@ webkit_web_view_set_custom_charset
 webkit_web_view_get_back_forward_list
 webkit_web_view_go_to_back_forward_list_item
 webkit_web_view_get_uri
+webkit_web_view_get_favicon
 webkit_web_view_set_settings
 webkit_web_view_get_settings
 webkit_web_view_get_window_properties
@@ -111,6 +115,8 @@ webkit_web_view_get_inspector
 webkit_web_view_get_javascript_global_context
 webkit_web_view_run_javascript
 webkit_web_view_run_javascript_finish
+webkit_web_view_run_javascript_from_gresource
+webkit_web_view_run_javascript_from_gresource_finish
 webkit_web_view_can_show_mime_type
 webkit_web_view_save
 webkit_web_view_save_finish
@@ -291,6 +297,8 @@ webkit_settings_set_enable_page_cache
 webkit_settings_get_user_agent
 webkit_settings_set_user_agent
 webkit_settings_set_user_agent_with_application_details
+webkit_settings_get_enable_smooth_scrolling
+webkit_settings_set_enable_smooth_scrolling
 
 <SUBSECTION Standard>
 WebKitSettingsClass
@@ -602,6 +610,31 @@ webkit_javascript_error_quark
 </SECTION>
 
 <SECTION>
+<FILE>WebKitFaviconDatabase</FILE>
+WebKitFaviconDatabase
+WEBKIT_FAVICON_DATABASE_ERROR
+WebKitFaviconDatabaseError
+webkit_favicon_database_get_favicon
+webkit_favicon_database_get_favicon_finish
+webkit_favicon_database_get_favicon_uri
+webkit_favicon_database_clear
+
+<SUBSECTION Standard>
+WebKitFaviconDatabaseClass
+WEBKIT_TYPE_FAVICON_DATABASE
+WEBKIT_FAVICON_DATABASE
+WEBKIT_IS_FAVICON_DATABASE
+WEBKIT_FAVICON_DATABASE_CLASS
+WEBKIT_IS_FAVICON_DATABASE_CLASS
+WEBKIT_FAVICON_DATABASE_GET_CLASS
+
+<SUBSECTION Private>
+WebKitFaviconDatabasePrivate
+webkit_favicon_database_get_type
+webkit_favicon_database_error_quark
+</SECTION>
+
+<SECTION>
 <FILE>WebKitFileChooserRequest</FILE>
 WebKitFileChooserRequest
 webkit_file_chooser_request_get_mime_types
@@ -745,6 +778,7 @@ WebKitURISchemeRequest
 webkit_uri_scheme_request_get_scheme
 webkit_uri_scheme_request_get_uri
 webkit_uri_scheme_request_get_path
+webkit_uri_scheme_request_get_web_view
 webkit_uri_scheme_request_finish
 
 <SUBSECTION Standard>
diff --git a/Source/WebKit2/UIProcess/API/gtk/tests/GNUmakefile.am b/Source/WebKit2/UIProcess/API/gtk/tests/GNUmakefile.am
index 3fadf40b4..06ea1af7c 100644
--- a/Source/WebKit2/UIProcess/API/gtk/tests/GNUmakefile.am
+++ b/Source/WebKit2/UIProcess/API/gtk/tests/GNUmakefile.am
@@ -11,6 +11,7 @@ TEST_PROGS += \
 	Programs/WebKit2APITests/TestResources \
 	Programs/WebKit2APITests/TestSSL \
 	Programs/WebKit2APITests/TestWebKitVersion \
+	Programs/WebKit2APITests/TestWebKitFaviconDatabase \
 	Programs/WebKit2APITests/TestWebKitFindController \
 	Programs/WebKit2APITests/TestWebKitPolicyClient \
 	Programs/WebKit2APITests/TestWebKitSettings \
@@ -29,6 +30,7 @@ endif
 webkit2_tests_cppflags = \
 	-DWEBKIT_EXEC_PATH=\"${shell pwd}/$(top_builddir)/Programs\" \
 	-DWEBKIT_SRC_DIR=\"${shell pwd}/${srcdir}\" \
+	-DWEBKIT_DERIVED_SRC_DIR=\"${shell pwd}/${top_builddir}/DerivedSources\" \
 	$(javascriptcore_cppflags) \
 	-I$(srcdir)/Source/JavaScriptCore \
 	-I$(srcdir)/Source \
@@ -55,6 +57,12 @@ webkit2_tests_ldflags = \
 	-no-install \
 	-no-fast-install
 
+DerivedSources/WebKit2/webkit2gtk-tests-resources.gresource: Source/WebKit2/UIProcess/API/gtk/tests/resources/webkit2gtk-tests.gresource.xml $(shell $(GLIB_COMPILE_RESOURCES) --generate-dependencies $(srcdir)/Source/WebKit2/UIProcess/API/gtk/tests/resources/webkit2gtk-tests.gresource.xml)
+	$(AM_V_GEN) $(GLIB_COMPILE_RESOURCES) --target=$@ --sourcedir=$(srcdir) $<
+
+DISTCLEANFILES += DerivedSources/WebKit2/webkit2gtk-tests-resources.gresource
+noinst_DATA += DerivedSources/WebKit2/webkit2gtk-tests-resources.gresource
+
 noinst_LTLIBRARIES += Libraries/libWebKit2APITestCore.la
 Libraries_libWebKit2APITestCore_la_SOURCES = \
 	Source/WebKit2/UIProcess/API/gtk/tests/LoadTrackingTest.cpp \
@@ -69,7 +77,9 @@ Libraries_libWebKit2APITestCore_la_CPPFLAGS = $(webkit2_tests_cppflags)
 
 EXTRA_DIST += \
 	Source/WebKit2/UIProcess/API/gtk/tests/resources/test-cert.pem \
-	Source/WebKit2/UIProcess/API/gtk/tests/resources/test-key.pem
+	Source/WebKit2/UIProcess/API/gtk/tests/resources/test-key.pem \
+	Source/WebKit2/UIProcess/API/gtk/tests/resources/webkit2gtk-tests.gresource.xml \
+	Source/WebKit2/UIProcess/API/gtk/tests/resources/link-title.js
 
 Programs_WebKit2APITests_TestWebKitWebContext_SOURCES = \
 	Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitWebContext.cpp
@@ -141,6 +151,12 @@ Programs_WebKit2APITests_TestPrinting_CPPFLAGS = $(webkit2_tests_cppflags) $(GTK
 Programs_WebKit2APITests_TestPrinting_LDADD = $(webkit2_tests_ldadd) $(GTK_UNIX_PRINTING_LIBS)
 Programs_WebKit2APITests_TestPrinting_LDFLAGS = $(webkit2_tests_ldflags)
 
+Programs_WebKit2APITests_TestWebKitFaviconDatabase_SOURCES = \
+	Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitFaviconDatabase.cpp
+Programs_WebKit2APITests_TestWebKitFaviconDatabase_CPPFLAGS = $(webkit2_tests_cppflags)
+Programs_WebKit2APITests_TestWebKitFaviconDatabase_LDADD = $(webkit2_tests_ldadd)
+Programs_WebKit2APITests_TestWebKitFaviconDatabase_LDFLAGS = $(webkit2_tests_ldflags)
+
 Programs_WebKit2APITests_TestWebKitFindController_SOURCES = \
 	Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitFindController.cpp
 Programs_WebKit2APITests_TestWebKitFindController_CPPFLAGS = $(webkit2_tests_cppflags)
diff --git a/Source/WebKit2/UIProcess/API/gtk/tests/TestBackForwardList.cpp b/Source/WebKit2/UIProcess/API/gtk/tests/TestBackForwardList.cpp
index e70e391ff..b479366a4 100644
--- a/Source/WebKit2/UIProcess/API/gtk/tests/TestBackForwardList.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/tests/TestBackForwardList.cpp
@@ -38,6 +38,11 @@ static void serverCallback(SoupServer* server, SoupMessage* msg, const char* pat
         return;
     }
 
+    if (g_str_has_suffix(path, "favicon.ico")) {
+        soup_message_set_status(msg, SOUP_STATUS_NOT_FOUND);
+        return;
+    }
+
     soup_message_set_status(msg, SOUP_STATUS_OK);
 
     char* body = g_strdup_printf("<html><title>%s</title><body>%s</body></html>", path + 1, path + 1);
diff --git a/Source/WebKit2/UIProcess/API/gtk/tests/TestCookieManager.cpp b/Source/WebKit2/UIProcess/API/gtk/tests/TestCookieManager.cpp
index 2fe8998b5..94aeef6e1 100644
--- a/Source/WebKit2/UIProcess/API/gtk/tests/TestCookieManager.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/tests/TestCookieManager.cpp
@@ -295,7 +295,7 @@ static void serverCallback(SoupServer* server, SoupMessage* message, const char*
     } else if (g_str_equal(path, "/image.png"))
         soup_message_headers_replace(message->response_headers, "Set-Cookie", "baz=qux; Max-Age=60");
     else
-        g_assert_not_reached();
+        soup_message_set_status(message, SOUP_STATUS_NOT_FOUND);
     soup_message_body_complete(message->response_body);
 }
 
diff --git a/Source/WebKit2/UIProcess/API/gtk/tests/TestLoaderClient.cpp b/Source/WebKit2/UIProcess/API/gtk/tests/TestLoaderClient.cpp
index c3a14193d..8fcf33009 100644
--- a/Source/WebKit2/UIProcess/API/gtk/tests/TestLoaderClient.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/tests/TestLoaderClient.cpp
@@ -312,7 +312,8 @@ static void serverCallback(SoupServer* server, SoupMessage* message, const char*
         soup_message_body_append(message->response_body, SOUP_MEMORY_STATIC, responseString, strlen(responseString));
         soup_server_unpause_message(server, message);
         return;
-    }
+    } else
+        soup_message_set_status(message, SOUP_STATUS_NOT_FOUND);
 
     soup_message_body_complete(message->response_body);
 }
diff --git a/Source/WebKit2/UIProcess/API/gtk/tests/TestMain.cpp b/Source/WebKit2/UIProcess/API/gtk/tests/TestMain.cpp
index 8622af19c..9db47f82b 100644
--- a/Source/WebKit2/UIProcess/API/gtk/tests/TestMain.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/tests/TestMain.cpp
@@ -25,12 +25,24 @@
 void beforeAll();
 void afterAll();
 
+static void registerGResource(void)
+{
+    GOwnPtr<char> resourcesPath(g_build_filename(WEBKIT_DERIVED_SRC_DIR, "WebKit2", "webkit2gtk-tests-resources.gresource", NULL));
+    GResource* resource = g_resource_load(resourcesPath.get(), 0);
+    g_assert(resource);
+
+    g_resources_register(resource);
+    g_resource_unref(resource);
+}
+
 int main(int argc, char** argv)
 {
     gtk_test_init(&argc, &argv, 0);
     g_setenv("WEBKIT_EXEC_PATH", WEBKIT_EXEC_PATH, FALSE);
     g_test_bug_base("https://bugs.webkit.org/");
 
+    registerGResource();
+
     beforeAll();
     int returnValue = g_test_run();
     afterAll();
diff --git a/Source/WebKit2/UIProcess/API/gtk/tests/TestResources.cpp b/Source/WebKit2/UIProcess/API/gtk/tests/TestResources.cpp
index 7e2e5de61..20b90b0b4 100644
--- a/Source/WebKit2/UIProcess/API/gtk/tests/TestResources.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/tests/TestResources.cpp
@@ -80,6 +80,11 @@ public:
     {
         test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(resource));
         test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(request));
+
+        // Ignore favicons.
+        if (g_str_has_suffix(webkit_uri_request_get_uri(request), "favicon.ico"))
+            return;
+
         test->resourceLoadStarted(resource, request);
         g_signal_connect(resource, "sent-request", G_CALLBACK(resourceSentRequestCallback), test);
         g_signal_connect(resource, "notify::response", G_CALLBACK(resourceReceivedResponseCallback), test);
@@ -507,21 +512,31 @@ static void testWebResourceGetData(ResourcesTest* test, gconstpointer)
 
 static void testWebViewResourcesHistoryCache(SingleResourceLoadTest* test, gconstpointer)
 {
-    test->loadURI(kServer->getURIForPath("/").data());
+    CString javascriptURI = kServer->getURIForPath("/javascript.html");
+    test->loadURI(javascriptURI.data());
     test->waitUntilResourceLoadFinished();
-    g_assert(webkit_web_view_get_main_resource(test->m_webView));
+    WebKitWebResource* resource = webkit_web_view_get_main_resource(test->m_webView);
+    g_assert(resource);
+    g_assert_cmpstr(webkit_web_resource_get_uri(resource), ==, javascriptURI.data());
 
-    test->loadURI(kServer->getURIForPath("/javascript.html").data());
+    CString simpleStyleCSSURI = kServer->getURIForPath("/simple-style-css.html");
+    test->loadURI(simpleStyleCSSURI.data());
     test->waitUntilResourceLoadFinished();
-    g_assert(webkit_web_view_get_main_resource(test->m_webView));
+    resource = webkit_web_view_get_main_resource(test->m_webView);
+    g_assert(resource);
+    g_assert_cmpstr(webkit_web_resource_get_uri(resource), ==, simpleStyleCSSURI.data());
 
     test->goBack();
     test->waitUntilResourceLoadFinished();
-    g_assert(webkit_web_view_get_main_resource(test->m_webView));
+    resource = webkit_web_view_get_main_resource(test->m_webView);
+    g_assert(resource);
+    g_assert_cmpstr(webkit_web_resource_get_uri(resource), ==, javascriptURI.data());
 
     test->goForward();
     test->waitUntilResourceLoadFinished();
-    g_assert(webkit_web_view_get_main_resource(test->m_webView));
+    resource = webkit_web_view_get_main_resource(test->m_webView);
+    g_assert(resource);
+    g_assert_cmpstr(webkit_web_resource_get_uri(resource), ==, simpleStyleCSSURI.data());
 }
 
 static void addCacheHTTPHeadersToResponse(SoupMessage* message)
@@ -567,6 +582,9 @@ static void serverCallback(SoupServer* server, SoupMessage* message, const char*
     } else if (g_str_equal(path, "/invalid-css.html")) {
         static const char* invalidCSSHtml = "<html><head><link rel='stylesheet' href='/invalid.css' type='text/css'></head><body></html>";
         soup_message_body_append(message->response_body, SOUP_MEMORY_STATIC, invalidCSSHtml, strlen(invalidCSSHtml));
+    } else if (g_str_equal(path, "/simple-style-css.html")) {
+        static const char* simpleStyleCSSHtml = "<html><head><link rel='stylesheet' href='/simple-style.css' type='text/css'></head><body></html>";
+        soup_message_body_append(message->response_body, SOUP_MEMORY_STATIC, simpleStyleCSSHtml, strlen(simpleStyleCSSHtml));
     } else if (g_str_equal(path, "/style.css")) {
         soup_message_body_append(message->response_body, SOUP_MEMORY_STATIC, kStyleCSS, strlen(kStyleCSS));
         addCacheHTTPHeadersToResponse(message);
@@ -594,6 +612,8 @@ static void serverCallback(SoupServer* server, SoupMessage* message, const char*
         soup_message_headers_append(message->response_headers, "Location", "/simple-style.css");
     } else if (g_str_equal(path, "/invalid.css"))
         soup_message_set_status(message, SOUP_STATUS_CANT_CONNECT);
+    else
+        soup_message_set_status(message, SOUP_STATUS_NOT_FOUND);
     soup_message_body_complete(message->response_body);
 }
 
diff --git a/Source/WebKit2/UIProcess/API/gtk/tests/TestSSL.cpp b/Source/WebKit2/UIProcess/API/gtk/tests/TestSSL.cpp
index 40e9fbeee..8fa013dc4 100644
--- a/Source/WebKit2/UIProcess/API/gtk/tests/TestSSL.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/tests/TestSSL.cpp
@@ -82,9 +82,12 @@ static void serverCallback(SoupServer* server, SoupMessage* message, const char*
         return;
     }
 
-    soup_message_set_status(message, SOUP_STATUS_OK);
-    soup_message_body_append(message->response_body, SOUP_MEMORY_STATIC, indexHTML, strlen(indexHTML));
-    soup_message_body_complete(message->response_body);
+    if (g_str_equal(path, "/")) {
+        soup_message_set_status(message, SOUP_STATUS_OK);
+        soup_message_body_append(message->response_body, SOUP_MEMORY_STATIC, indexHTML, strlen(indexHTML));
+        soup_message_body_complete(message->response_body);
+    } else
+        soup_message_set_status(message, SOUP_STATUS_NOT_FOUND);
 }
 
 void beforeAll()
diff --git a/Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitFaviconDatabase.cpp b/Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitFaviconDatabase.cpp
new file mode 100644
index 000000000..40fb5a17a
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitFaviconDatabase.cpp
@@ -0,0 +1,246 @@
+/*
+ * Copyright (C) 2012 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 "WebKitTestServer.h"
+#include "WebViewTest.h"
+#include <glib/gstdio.h>
+#include <libsoup/soup.h>
+#include <wtf/gobject/GOwnPtr.h>
+
+static WebKitTestServer* kServer;
+static char* kTempDirectory;
+
+class FaviconDatabaseTest: public WebViewTest {
+public:
+    MAKE_GLIB_TEST_FIXTURE(FaviconDatabaseTest);
+
+    FaviconDatabaseTest()
+        : m_webContext(webkit_web_context_get_default())
+        , m_favicon(0)
+        , m_error(0)
+        , m_iconReadySignalReceived(false)
+        , m_faviconNotificationReceived(false)
+    {
+        WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(m_webContext);
+        g_signal_connect(database, "favicon-ready", G_CALLBACK(iconReadyCallback), this);
+    }
+
+    ~FaviconDatabaseTest()
+    {
+        if (m_favicon)
+            cairo_surface_destroy(m_favicon);
+
+        WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(m_webContext);
+        g_signal_handlers_disconnect_matched(database, G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, this);
+    }
+
+    static void iconReadyCallback(WebKitFaviconDatabase* database, const char* pageURI, FaviconDatabaseTest* test)
+    {
+        g_assert_cmpstr(webkit_web_view_get_uri(test->m_webView), ==, pageURI);
+        test->m_iconReadySignalReceived = true;
+    }
+
+    static void faviconChangedCallback(WebKitWebView* webView, GParamSpec* pspec, gpointer data)
+    {
+        FaviconDatabaseTest* test = static_cast<FaviconDatabaseTest*>(data);
+        g_assert(test->m_webView == webView);
+        test->m_faviconNotificationReceived = true;
+        test->quitMainLoop();
+    }
+
+    static void getFaviconCallback(GObject* sourceObject, GAsyncResult* result, void* data)
+    {
+        FaviconDatabaseTest* test = static_cast<FaviconDatabaseTest*>(data);
+        WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(test->m_webContext);
+        test->m_favicon = webkit_favicon_database_get_favicon_finish(database, result, &test->m_error.outPtr());
+        test->quitMainLoop();
+    }
+
+    void waitUntilFaviconChanged()
+    {
+        m_faviconNotificationReceived = false;
+        unsigned long handlerID = g_signal_connect(m_webView, "notify::favicon", G_CALLBACK(faviconChangedCallback), this);
+        g_main_loop_run(m_mainLoop);
+        g_signal_handler_disconnect(m_webView, handlerID);
+    }
+
+    void getFaviconForPageURIAndWaitUntilReady(const char* pageURI)
+    {
+        m_error.clear();
+        if (m_favicon) {
+            cairo_surface_destroy(m_favicon);
+            m_favicon = 0;
+        }
+        WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(m_webContext);
+        webkit_favicon_database_get_favicon(database, pageURI, 0, getFaviconCallback, this);
+        g_main_loop_run(m_mainLoop);
+    }
+
+    WebKitWebContext* m_webContext;
+    cairo_surface_t* m_favicon;
+    GOwnPtr<GError> m_error;
+    bool m_iconReadySignalReceived;
+    bool m_faviconNotificationReceived;
+};
+
+static void
+serverCallback(SoupServer* server, SoupMessage* message, const char* path, GHashTable* query, SoupClientContext* context, void* data)
+{
+    if (message->method != SOUP_METHOD_GET) {
+        soup_message_set_status(message, SOUP_STATUS_NOT_IMPLEMENTED);
+        return;
+    }
+
+    char* contents;
+    gsize length;
+    if (g_str_equal(path, "/favicon.ico")) {
+        GOwnPtr<char> pathToFavicon(g_build_filename(Test::getWebKit1TestResoucesDir().data(), "blank.ico", NULL));
+        g_file_get_contents(pathToFavicon.get(), &contents, &length, 0);
+    } else if (g_str_equal(path, "/nofavicon/favicon.ico")) {
+        soup_message_set_status(message, SOUP_STATUS_NOT_FOUND);
+        soup_message_body_complete(message->response_body);
+        return;
+    } else {
+        contents = g_strdup("<html><body>test</body></html>");
+        length = strlen(contents);
+    }
+
+    soup_message_set_status(message, SOUP_STATUS_OK);
+    soup_message_body_append(message->response_body, SOUP_MEMORY_TAKE, contents, length);
+    soup_message_body_complete(message->response_body);
+}
+
+static void testNotInitialized(FaviconDatabaseTest* test, gconstpointer)
+{
+    // Try to retrieve a valid favicon from a not initialized database.
+    test->getFaviconForPageURIAndWaitUntilReady(kServer->getURIForPath("/").data());
+    g_assert(!test->m_favicon);
+    g_assert(test->m_error);
+    g_assert_cmpint(test->m_error->code, ==, WEBKIT_FAVICON_DATABASE_ERROR_NOT_INITIALIZED);
+}
+
+static void testSetDirectory(FaviconDatabaseTest* test, gconstpointer)
+{
+    webkit_web_context_set_favicon_database_directory(test->m_webContext, kTempDirectory);
+    g_assert_cmpstr(kTempDirectory, ==, webkit_web_context_get_favicon_database_directory(test->m_webContext));
+}
+
+static void testClearDatabase(FaviconDatabaseTest* test, gconstpointer)
+{
+    WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(test->m_webContext);
+    webkit_favicon_database_clear(database);
+
+    GOwnPtr<char> iconURI(webkit_favicon_database_get_favicon_uri(database, kServer->getURIForPath("/").data()));
+    g_assert(!iconURI);
+}
+
+static void testGetFavicon(FaviconDatabaseTest* test, gconstpointer)
+{
+    // We need to load the page first to ensure the icon data will be
+    // in the database in case there's an associated favicon.
+    test->loadURI(kServer->getURIForPath("/").data());
+    test->waitUntilFaviconChanged();
+    g_assert(test->m_iconReadySignalReceived);
+
+    // Check the API retrieving a valid favicon.
+    test->m_iconReadySignalReceived = false;
+    test->getFaviconForPageURIAndWaitUntilReady(kServer->getURIForPath("/").data());
+    g_assert(test->m_favicon);
+    g_assert(!test->m_error);
+    g_assert(!test->m_iconReadySignalReceived);
+
+    // Check that width and height match those from blank.ico (16x16 favicon).
+    g_assert_cmpint(cairo_image_surface_get_width(test->m_favicon), ==, 16);
+    g_assert_cmpint(cairo_image_surface_get_height(test->m_favicon), ==, 16);
+
+    // Check the API retrieving an invalid favicon.
+    test->loadURI(kServer->getURIForPath("/nofavicon").data());
+    test->waitUntilFaviconChanged();
+    g_assert(!test->m_iconReadySignalReceived);
+
+    test->getFaviconForPageURIAndWaitUntilReady(kServer->getURIForPath("/nofavicon/").data());
+    g_assert(!test->m_favicon);
+    g_assert(test->m_error);
+    g_assert(!test->m_iconReadySignalReceived);
+}
+
+static void testGetFaviconURI(FaviconDatabaseTest* test, gconstpointer)
+{
+    WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(test->m_webContext);
+
+    const char* baseURI = kServer->getURIForPath("/").data();
+    GOwnPtr<char> iconURI(webkit_favicon_database_get_favicon_uri(database, baseURI));
+    g_assert_cmpstr(iconURI.get(), ==, kServer->getURIForPath("/favicon.ico").data());
+}
+
+static void testWebViewFavicon(FaviconDatabaseTest* test, gconstpointer)
+{
+    cairo_surface_t* iconFromWebView = webkit_web_view_get_favicon(test->m_webView);
+    g_assert(!iconFromWebView);
+
+    test->loadURI(kServer->getURIForPath("/").data());
+    test->waitUntilFaviconChanged();
+    g_assert(test->m_faviconNotificationReceived);
+
+    iconFromWebView = webkit_web_view_get_favicon(test->m_webView);
+    g_assert(iconFromWebView);
+    g_assert_cmpuint(cairo_image_surface_get_width(iconFromWebView), ==, 16);
+    g_assert_cmpuint(cairo_image_surface_get_height(iconFromWebView), ==, 16);
+}
+
+void beforeAll()
+{
+    // Start a soup server for testing.
+    kServer = new WebKitTestServer();
+    kServer->run(serverCallback);
+
+    kTempDirectory = g_dir_make_tmp("WebKit2Tests-XXXXXX", 0);
+    g_assert(kTempDirectory);
+
+    // Add tests to the suite.
+    FaviconDatabaseTest::add("WebKitFaviconDatabase", "not-initialized", testNotInitialized);
+    FaviconDatabaseTest::add("WebKitFaviconDatabase", "set-directory", testSetDirectory);
+    FaviconDatabaseTest::add("WebKitFaviconDatabase", "get-favicon", testGetFavicon);
+    FaviconDatabaseTest::add("WebKitFaviconDatabase", "get-favicon-uri", testGetFaviconURI);
+    FaviconDatabaseTest::add("WebKitFaviconDatabase", "clear-database", testClearDatabase);
+    FaviconDatabaseTest::add("WebKitWebView", "favicon", testWebViewFavicon);
+}
+
+static void webkitFaviconDatabaseFinalizedCallback(gpointer, GObject*)
+{
+    if (!g_file_test(kTempDirectory, G_FILE_TEST_IS_DIR))
+        return;
+
+    GOwnPtr<char> filename(g_build_filename(kTempDirectory, "WebpageIcons.db", NULL));
+    g_unlink(filename.get());
+
+    g_rmdir(kTempDirectory);
+}
+
+void afterAll()
+{
+    delete kServer;
+
+    // Delete the temporary files after the IconDatabase has been
+    // closed, that is, once WebKitFaviconDatabase is being destroyed.
+    WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(webkit_web_context_get_default());
+    g_object_weak_ref(G_OBJECT(database), webkitFaviconDatabaseFinalizedCallback, 0);
+}
diff --git a/Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitPolicyClient.cpp b/Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitPolicyClient.cpp
index 9f6ce7819..abbfd652a 100644
--- a/Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitPolicyClient.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitPolicyClient.cpp
@@ -232,11 +232,13 @@ static void serverCallback(SoupServer* server, SoupMessage* message, const char*
         return;
     }
 
-    soup_message_set_status(message, SOUP_STATUS_OK);
-
-    static const char* responseString = "<html><body>Testing!</body></html>";
-    soup_message_body_append(message->response_body, SOUP_MEMORY_STATIC, responseString, strlen(responseString));
-    soup_message_body_complete(message->response_body);
+    if (g_str_equal(path, "/")) {
+        static const char* responseString = "<html><body>Testing!</body></html>";
+        soup_message_set_status(message, SOUP_STATUS_OK);
+        soup_message_body_append(message->response_body, SOUP_MEMORY_STATIC, responseString, strlen(responseString));
+        soup_message_body_complete(message->response_body);
+    } else
+        soup_message_set_status(message, SOUP_STATUS_NOT_FOUND);
 }
 
 void beforeAll()
diff --git a/Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitSettings.cpp b/Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitSettings.cpp
index d8e355472..c7a0dc259 100644
--- a/Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitSettings.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitSettings.cpp
@@ -243,6 +243,11 @@ static void testWebKitSettings(Test*, gconstpointer)
     webkit_settings_set_enable_page_cache(settings, FALSE);
     g_assert(!webkit_settings_get_enable_page_cache(settings));
 
+    // By default, smooth scrolling is disabled.
+    g_assert(!webkit_settings_get_enable_smooth_scrolling(settings));
+    webkit_settings_set_enable_smooth_scrolling(settings, TRUE);
+    g_assert(webkit_settings_get_enable_smooth_scrolling(settings));
+
     g_object_unref(G_OBJECT(settings));
 }
 
@@ -315,10 +320,13 @@ static void serverCallback(SoupServer* server, SoupMessage* message, const char*
         return;
     }
 
-    soup_message_set_status(message, SOUP_STATUS_OK);
-    const char* userAgent = soup_message_headers_get_one(message->request_headers, "User-Agent");
-    soup_message_body_append(message->response_body, SOUP_MEMORY_COPY, userAgent, strlen(userAgent));
-    soup_message_body_complete(message->response_body);
+    if (g_str_equal(path, "/")) {
+        const char* userAgent = soup_message_headers_get_one(message->request_headers, "User-Agent");
+        soup_message_set_status(message, SOUP_STATUS_OK);
+        soup_message_body_append(message->response_body, SOUP_MEMORY_COPY, userAgent, strlen(userAgent));
+        soup_message_body_complete(message->response_body);
+    } else
+        soup_message_set_status(message, SOUP_STATUS_NOT_FOUND);
 }
 
 void beforeAll()
diff --git a/Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitWebContext.cpp b/Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitWebContext.cpp
index 7a13d285d..185c06cfe 100644
--- a/Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitWebContext.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitWebContext.cpp
@@ -146,6 +146,8 @@ public:
         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()));
 
@@ -291,10 +293,13 @@ static void serverCallback(SoupServer* server, SoupMessage* message, const char*
         return;
     }
 
-    soup_message_set_status(message, SOUP_STATUS_OK);
-    const char* acceptLanguage = soup_message_headers_get_one(message->request_headers, "Accept-Language");
-    soup_message_body_append(message->response_body, SOUP_MEMORY_COPY, acceptLanguage, strlen(acceptLanguage));
-    soup_message_body_complete(message->response_body);
+    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 {
diff --git a/Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitWebView.cpp b/Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitWebView.cpp
index 02e8138de..f5197b936 100644
--- a/Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitWebView.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/tests/TestWebKitWebView.cpp
@@ -643,6 +643,17 @@ static void testWebViewRunJavaScript(WebViewTest* test, gconstpointer)
     g_assert(!error.get());
     g_assert(WebViewTest::javascriptResultIsUndefined(javascriptResult));
 
+    javascriptResult = test->runJavaScriptFromGResourceAndWaitUntilFinished("/org/webkit/webkit2gtk/tests/link-title.js", &error.outPtr());
+    g_assert(javascriptResult);
+    g_assert(!error.get());
+    valueString.set(WebViewTest::javascriptResultToCString(javascriptResult));
+    g_assert_cmpstr(valueString.get(), ==, "WebKitGTK+ Title");
+
+    javascriptResult = test->runJavaScriptFromGResourceAndWaitUntilFinished("/wrong/path/to/resource.js", &error.outPtr());
+    g_assert(!javascriptResult);
+    g_assert_error(error.get(), G_RESOURCE_ERROR, G_RESOURCE_ERROR_NOT_FOUND);
+    error.clear();
+
     javascriptResult = test->runJavaScriptAndWaitUntilFinished("foo();", &error.outPtr());
     g_assert(!javascriptResult);
     g_assert_error(error.get(), WEBKIT_JAVASCRIPT_ERROR, WEBKIT_JAVASCRIPT_ERROR_SCRIPT_FAILED);
diff --git a/Source/WebKit2/UIProcess/API/gtk/tests/WebViewTest.cpp b/Source/WebKit2/UIProcess/API/gtk/tests/WebViewTest.cpp
index 04747480e..7e7eb0167 100644
--- a/Source/WebKit2/UIProcess/API/gtk/tests/WebViewTest.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/tests/WebViewTest.cpp
@@ -313,6 +313,12 @@ static void runJavaScriptReadyCallback(GObject*, GAsyncResult* result, WebViewTe
     g_main_loop_quit(test->m_mainLoop);
 }
 
+static void runJavaScriptFromGResourceReadyCallback(GObject*, GAsyncResult* result, WebViewTest* test)
+{
+    test->m_javascriptResult = webkit_web_view_run_javascript_from_gresource_finish(test->m_webView, result, test->m_javascriptError);
+    g_main_loop_quit(test->m_mainLoop);
+}
+
 WebKitJavascriptResult* WebViewTest::runJavaScriptAndWaitUntilFinished(const char* javascript, GError** error)
 {
     if (m_javascriptResult)
@@ -325,6 +331,18 @@ WebKitJavascriptResult* WebViewTest::runJavaScriptAndWaitUntilFinished(const cha
     return m_javascriptResult;
 }
 
+WebKitJavascriptResult* WebViewTest::runJavaScriptFromGResourceAndWaitUntilFinished(const char* resource, GError** error)
+{
+    if (m_javascriptResult)
+        webkit_javascript_result_unref(m_javascriptResult);
+    m_javascriptResult = 0;
+    m_javascriptError = error;
+    webkit_web_view_run_javascript_from_gresource(m_webView, resource, 0, reinterpret_cast<GAsyncReadyCallback>(runJavaScriptFromGResourceReadyCallback), this);
+    g_main_loop_run(m_mainLoop);
+
+    return m_javascriptResult;
+}
+
 static char* jsValueToCString(JSGlobalContextRef context, JSValueRef value)
 {
     g_assert(value);
diff --git a/Source/WebKit2/UIProcess/API/gtk/tests/WebViewTest.h b/Source/WebKit2/UIProcess/API/gtk/tests/WebViewTest.h
index 25209caa3..06f398f96 100644
--- a/Source/WebKit2/UIProcess/API/gtk/tests/WebViewTest.h
+++ b/Source/WebKit2/UIProcess/API/gtk/tests/WebViewTest.h
@@ -55,6 +55,7 @@ public:
     void keyStroke(unsigned int keyVal, unsigned int keyModifiers = 0);
 
     WebKitJavascriptResult* runJavaScriptAndWaitUntilFinished(const char* javascript, GError**);
+    WebKitJavascriptResult* runJavaScriptFromGResourceAndWaitUntilFinished(const char* resource, GError**);
 
     // Javascript result helpers.
     static char* javascriptResultToCString(WebKitJavascriptResult*);
diff --git a/Source/WebKit2/UIProcess/API/gtk/tests/resources/link-title.js b/Source/WebKit2/UIProcess/API/gtk/tests/resources/link-title.js
new file mode 100644
index 000000000..2c824da38
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/gtk/tests/resources/link-title.js
@@ -0,0 +1 @@
+window.document.getElementById('WebKitLink').title;
diff --git a/Source/WebKit2/UIProcess/API/gtk/tests/resources/webkit2gtk-tests.gresource.xml b/Source/WebKit2/UIProcess/API/gtk/tests/resources/webkit2gtk-tests.gresource.xml
new file mode 100644
index 000000000..4f1e5a654
--- /dev/null
+++ b/Source/WebKit2/UIProcess/API/gtk/tests/resources/webkit2gtk-tests.gresource.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<gresources>
+  <gresource prefix="/org/webkit/webkit2gtk/tests/">
+    <file alias="link-title.js">Source/WebKit2/UIProcess/API/gtk/tests/resources/link-title.js</file>
+  </gresource>
+</gresources>
diff --git a/Source/WebKit2/UIProcess/API/gtk/webkit2.h b/Source/WebKit2/UIProcess/API/gtk/webkit2.h
index e1f3ba04a..1b4fa86a1 100644
--- a/Source/WebKit2/UIProcess/API/gtk/webkit2.h
+++ b/Source/WebKit2/UIProcess/API/gtk/webkit2.h
@@ -34,6 +34,7 @@
 #include <webkit2/WebKitEditingCommands.h>
 #include <webkit2/WebKitEnumTypes.h>
 #include <webkit2/WebKitError.h>
+#include <webkit2/WebKitFaviconDatabase.h>
 #include <webkit2/WebKitFileChooserRequest.h>
 #include <webkit2/WebKitFindController.h>
 #include <webkit2/WebKitFormSubmissionRequest.h>